/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 1.3.41
 * 
 * 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. 
 * ----------------------------------------------------------------------------- */

#define SWIGPYTHON
#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 (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#  ifndef GCC_HASCLASSVISIBILITY
#    define GCC_HASCLASSVISIBILITY
#  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



/* Python.h has to appear first */
#include <Python.h>

/* -----------------------------------------------------------------------------
 * 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

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


/* 
   Flags/methods for returning states.
   
   The SWIG conversion methods, as ConvertPtr, return and 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
#  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 not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
  int equiv = 0;
  const char* te = tb + strlen(tb);
  const char* ne = nb;
  while (!equiv && *ne) {
    for (nb = ne; *ne; ++ne) {
      if (*ne == '|') break;
    }
    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
    if (*ne) ++ne;
  }
  return equiv;
}

/*
  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_TypeCompare(const char *nb, const char *tb) {
  int equiv = 0;
  const char* te = tb + strlen(tb);
  const char* ne = nb;
  while (!equiv && *ne) {
    for (nb = ne; *ne; ++ne) {
      if (*ne == '|') break;
    }
    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
    if (*ne) ++ne;
  }
  return equiv;
}


/*
  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) {
      register size_t l = 0;
      register size_t r = iter->size - 1;
      do {
	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
	register size_t i = (l + r) >> 1; 
	const char *iname = iter->types[i]->name;
	if (iname) {
	  register 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 {
      register 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";
  register const unsigned char *u = (unsigned char *) ptr;
  register const unsigned char *eu =  u + sz;
  for (; u != eu; ++u) {
    register 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) {
  register unsigned char *u = (unsigned char *) ptr;
  register const unsigned char *eu = u + sz;
  for (; u != eu; ++u) {
    register char d = *(c++);
    register unsigned char uu;
    if ((d >= '0') && (d <= '9'))
      uu = ((d - '0') << 4);
    else if ((d >= 'a') && (d <= 'f'))
      uu = ((d - ('a'-10)) << 4);
    else 
      return (char *) 0;
    d = *(c++);
    if ((d >= '0') && (d <= '9'))
      uu |= (d - '0');
    else if ((d >= 'a') && (d <= 'f'))
      uu |= (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 PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)

#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 *cstr;
  char *newstr;
  Py_ssize_t len;
  str = PyUnicode_AsUTF8String(str);
  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
}

/* Add PyOS_snprintf for old Pythons */
#if PY_VERSION_HEX < 0x02020000
# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
#  define PyOS_snprintf _snprintf
# else
#  define PyOS_snprintf snprintf
# endif
#endif

/* A crude PyString_FromFormat implementation for old Pythons */
#if PY_VERSION_HEX < 0x02020000

#ifndef SWIG_PYBUFFER_SIZE
# define SWIG_PYBUFFER_SIZE 1024
#endif

static PyObject *
PyString_FromFormat(const char *fmt, ...) {
  va_list ap;
  char buf[SWIG_PYBUFFER_SIZE * 2];
  int res;
  va_start(ap, fmt);
  res = vsnprintf(buf, sizeof(buf), fmt, ap);
  va_end(ap);
  return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
}
#endif

/* Add PyObject_Del for old Pythons */
#if PY_VERSION_HEX < 0x01060000
# define PyObject_Del(op) PyMem_DEL((op))
#endif
#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif

/* A crude PyExc_StopIteration exception for old Pythons */
#if PY_VERSION_HEX < 0x02020000
# ifndef PyExc_StopIteration
#  define PyExc_StopIteration PyExc_RuntimeError
# endif
# ifndef PyObject_GenericGetAttr
#  define PyObject_GenericGetAttr 0
# endif
#endif

/* Py_NotImplemented is defined in 2.1 and up. */
#if PY_VERSION_HEX < 0x02010000
# ifndef Py_NotImplemented
#  define Py_NotImplemented PyExc_RuntimeError
# endif
#endif

/* A crude PyString_AsStringAndSize implementation for old Pythons */
#if PY_VERSION_HEX < 0x02010000
# ifndef PyString_AsStringAndSize
#  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
# endif
#endif

/* PySequence_Size for old Pythons */
#if PY_VERSION_HEX < 0x02000000
# ifndef PySequence_Size
#  define PySequence_Size PySequence_Length
# endif
#endif

/* PyBool_FromLong for old Pythons */
#if PY_VERSION_HEX < 0x02030000
static
PyObject *PyBool_FromLong(long ok)
{
  PyObject *result = ok ? Py_True : Py_False;
  Py_INCREF(result);
  return result;
}
#endif

/* Py_ssize_t for old Pythons */
/* This code is as recommended by: */
/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
typedef int Py_ssize_t;
# define PY_SSIZE_T_MAX INT_MAX
# define PY_SSIZE_T_MIN INT_MIN
#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) {
    char *tmp;
    PyObject *old_str = PyObject_Str(value);
    PyErr_Clear();
    Py_XINCREF(type);

    PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
    SWIG_Python_str_DelForPy3(tmp);
    Py_DECREF(old_str);
    Py_DECREF(value);
  } else {
    PyErr_SetString(PyExc_RuntimeError, mesg);
  }
}

#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)
#    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
#      define SWIG_PYTHON_USE_GIL
#    endif
#  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" {
#if 0
} /* cc-mode */
#endif
#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;
  char *name;
  long lvalue;
  double dvalue;
  void   *pvalue;
  swig_type_info **ptype;
} swig_const_info;


/* -----------------------------------------------------------------------------
 * Wrapper of PyInstanceMethod_New() used in Python 3
 * It is exported to the generated module, used for -fastproxy
 * ----------------------------------------------------------------------------- */
SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *self, PyObject *func)
{
#if PY_VERSION_HEX >= 0x03000000
  return PyInstanceMethod_New(func);
#else
  return NULL;
#endif
}

#ifdef __cplusplus
#if 0
{ /* cc-mode */
#endif
}
#endif


/* -----------------------------------------------------------------------------
 * See the LICENSE file for information on copyright, usage and redistribution
 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
 *
 * pyrun.swg
 *
 * This file contains the runtime support for Python modules
 * and includes code for managing global variables and pointer
 * type checking.
 *
 * ----------------------------------------------------------------------------- */

/* Common SWIG API */

#if PY_VERSION_HEX < 0x02050000
typedef int Py_ssize_t;
#endif

/* 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)
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(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(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()
#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, (char *) 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 */

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

/* Append a value to the result obj */

SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
  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;
#else
  PyObject*   o2;
  PyObject*   o3;
  if (!result) {
    result = obj;
  } else if (result == Py_None) {
    Py_DECREF(result);
    result = obj;
  } else {
    if (!PyTuple_Check(result)) {
      o2 = result;
      result = PyTuple_New(1);
      PyTuple_SET_ITEM(result, 0, o2);
    }
    o3 = PyTuple_New(1);
    PyTuple_SET_ITEM(o3, 0, obj);
    o2 = result;
    result = PySequence_Concat(o2, o3);
    Py_DECREF(o2);
    Py_DECREF(o3);
  }
  return result;
#endif
}

/* Unpack the argument tuple */

SWIGINTERN int
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)) {
    PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
    return 0;
  } else {
    register 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 {
      register int 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 */
#if PY_VERSION_HEX >= 0x02020000
#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunctionObjArgs(functor, obj, NULL);
#else
#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunction(functor, "O", obj);
#endif

/*
  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)

#ifdef __cplusplus
extern "C" {
#if 0
} /* cc-mode */
#endif
#endif

/*  How to access Py_None */
#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#  ifndef SWIG_PYTHON_NO_BUILD_NONE
#    ifndef SWIG_PYTHON_BUILD_NONE
#      define SWIG_PYTHON_BUILD_NONE
#    endif
#  endif
#endif

#ifdef SWIG_PYTHON_BUILD_NONE
#  ifdef Py_None
#   undef Py_None
#   define Py_None SWIG_Py_None()
#  endif
SWIGRUNTIMEINLINE PyObject * 
_SWIG_Py_None(void)
{
  PyObject *none = Py_BuildValue((char*)"");
  Py_DECREF(none);
  return none;
}
SWIGRUNTIME PyObject * 
SWIG_Py_None(void)
{
  static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
  return none;
}
#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;
} SwigPyClientData;

SWIGRUNTIMEINLINE int 
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
  SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
  return data ? data->implicitconv : 0;
}

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 {
#if (PY_VERSION_HEX < 0x02020000)
      data->newraw = 0;
#else
      data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
#endif
      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, (char *)"__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);
#ifdef METH_O
      data->delargs = !(flags & (METH_O));
#else
      data->delargs = 0;
#endif
    } else {
      data->delargs = 0;
    }
    data->implicitconv = 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;
} SwigPyObject;

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 *
#ifdef METH_NOARGS
SwigPyObject_repr(SwigPyObject *v)
#else
SwigPyObject_repr(SwigPyObject *v, PyObject *args)
#endif
{
  const char *name = SWIG_TypePrettyName(v->ty);
  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", name, v);
  if (v->next) {
#ifdef METH_NOARGS
    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
#else
    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
#endif
#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;  
}

SWIGRUNTIME int
SwigPyObject_print(SwigPyObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
{
  char *str;
#ifdef METH_NOARGS
  PyObject *repr = SwigPyObject_repr(v);
#else
  PyObject *repr = SwigPyObject_repr(v, NULL);
#endif
  if (repr) {
    str = SWIG_Python_str_AsChar(repr); 
    fputs(str, fp);
    SWIG_Python_str_DelForPy3(str);
    Py_DECREF(repr);
    return 0; 
  } else {
    return 1; 
  }
}

SWIGRUNTIME PyObject *
SwigPyObject_str(SwigPyObject *v)
{
  char result[SWIG_BUFFER_SIZE];
  return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
    SWIG_Python_str_FromChar(result) : 0;
}

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;
  }
  if( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) )
    res = Py_True;
  else
    res = Py_False;
  Py_INCREF(res);
  return res;  
}


SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);

SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
  return type;
}

SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
  return (Py_TYPE(op) == SwigPyObject_type())
    || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
}

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;
      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));
      }
      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;
#ifndef METH_O
  PyObject *tmp = 0;
  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
  next = tmp;
#endif
  if (!SwigPyObject_Check(next)) {
    return NULL;
  }
  sobj->next = next;
  Py_INCREF(next);
  return SWIG_Py_Void();
}

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

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

SWIGINTERN PyObject*
#ifdef METH_NOARGS
SwigPyObject_acquire(PyObject *v)
#else
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
#endif
{
  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 (PY_VERSION_HEX < 0x02020000)
  if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
#else
  if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) 
#endif
    {
      return NULL;
    } 
  else
    {
      SwigPyObject *sobj = (SwigPyObject *)v;
      PyObject *obj = PyBool_FromLong(sobj->own);
      if (val) {
#ifdef METH_NOARGS
	if (PyObject_IsTrue(val)) {
	  SwigPyObject_acquire(v);
	} else {
	  SwigPyObject_disown(v);
	}
#else
	if (PyObject_IsTrue(val)) {
	  SwigPyObject_acquire(v,args);
	} else {
	  SwigPyObject_disown(v,args);
	}
#endif
      } 
      return obj;
    }
}

#ifdef METH_O
static PyMethodDef
swigobject_methods[] = {
  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)"appends another 'this' object"},
  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
  {0, 0, 0, 0}  
};
#else
static PyMethodDef
swigobject_methods[] = {
  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
  {0, 0, 0, 0}  
};
#endif

#if PY_VERSION_HEX < 0x02020000
SWIGINTERN PyObject *
SwigPyObject_getattr(SwigPyObject *sobj,char *name)
{
  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
}
#endif

SWIGRUNTIME PyTypeObject*
_PySwigObject_type(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 >= 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 */
#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
    0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
#endif
  };

  static PyTypeObject swigpyobject_type;  
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp
      = {
	/* PyObject header changed in Python 3 */
#if PY_VERSION_HEX >= 0x03000000
	PyVarObject_HEAD_INIT(&PyType_Type, 0)
#else    
	PyObject_HEAD_INIT(NULL)
	0,				    /* ob_size */
#endif
	(char *)"SwigPyObject",		    /* tp_name */
	sizeof(SwigPyObject),		    /* tp_basicsize */
	0,			            /* tp_itemsize */
	(destructor)SwigPyObject_dealloc,   /* tp_dealloc */
	(printfunc)SwigPyObject_print,	    /* tp_print */
#if PY_VERSION_HEX < 0x02020000
	(getattrfunc)SwigPyObject_getattr,  /* tp_getattr */ 
#else
	(getattrfunc)0,			    /* tp_getattr */ 
#endif
	(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 */
	(reprfunc)SwigPyObject_str,	    /* 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 */
#if PY_VERSION_HEX >= 0x02020000
	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 */
#endif
#if PY_VERSION_HEX >= 0x02030000
	0,                                  /* tp_del */
#endif
#ifdef COUNT_ALLOCS
	0,0,0,0                             /* tp_alloc -> tp_next */
#endif
      };
    swigpyobject_type = tmp;
    /* for Python 3 we already assigned ob_type in PyVarObject_HEAD_INIT() */
#if PY_VERSION_HEX < 0x03000000
    swigpyobject_type.ob_type = &PyType_Type;
#endif
    type_init = 1;
  }
  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 int
SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
{
  char result[SWIG_BUFFER_SIZE];
  fputs("<Swig Packed ", fp); 
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    fputs("at ", fp); 
    fputs(result, fp); 
  }
  fputs(v->ty->name,fp); 
  fputs(">", fp);
  return 0; 
}
  
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((char *)v->pack, (char *)w->pack, 2*v->size);
}

SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);

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

SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
  return ((op)->ob_type == _PySwigPacked_type()) 
    || (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*
_PySwigPacked_type(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
      = {
    /* PyObject header changed in Python 3 */
#if PY_VERSION_HEX>=0x03000000
    PyVarObject_HEAD_INIT(&PyType_Type, 0)
#else
	PyObject_HEAD_INIT(NULL)
    0,				    /* ob_size */	
#endif
	(char *)"SwigPyPacked",		    /* tp_name */	
	sizeof(SwigPyPacked),		    /* tp_basicsize */	
	0,				    /* tp_itemsize */	
	(destructor)SwigPyPacked_dealloc,   /* tp_dealloc */	
	(printfunc)SwigPyPacked_print,	    /* 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 */
#if PY_VERSION_HEX >= 0x02020000
	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 */
#endif
#if PY_VERSION_HEX >= 0x02030000
	0,                                  /* tp_del */
#endif
#ifdef COUNT_ALLOCS
	0,0,0,0                             /* tp_alloc -> tp_next */
#endif
      };
    swigpypacked_type = tmp;
    /* for Python 3 the ob_type already assigned in PyVarObject_HEAD_INIT() */
#if PY_VERSION_HEX < 0x03000000
    swigpypacked_type.ob_type = &PyType_Type;
#endif
    type_init = 1;
  }
  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
 * ----------------------------------------------------------------------------- */

SWIGRUNTIMEINLINE PyObject *
_SWIG_This(void)
{
    return SWIG_Python_str_FromChar("this");
}

SWIGRUNTIME PyObject *
SWIG_This(void)
{
  static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
  return swig_this;
}

/* #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) 
{
  if (SwigPyObject_Check(pyobj)) {
    return (SwigPyObject *) pyobj;
  } else {
    PyObject *obj = 0;
#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
    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;
  }
}

/* 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) {
  if (!obj) return SWIG_ERROR;
  if (obj == Py_None) {
    if (ptr) *ptr = 0;
    return SWIG_OK;
  } else {
    SwigPyObject *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;
      }
      return SWIG_OK;
    } else {
      int res = SWIG_ERROR;
      if (flags & SWIG_POINTER_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);
	    }
	  }
	}
      }
      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;
    
    /* 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;
    if (ty) {
      swig_cast_info *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;
      }
    } else {
      *ptr = vptr;
    }
    return SWIG_OK;
  }
}

/* Convert a packed value 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)
{
#if (PY_VERSION_HEX >= 0x02020000)
  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
    inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
    PyObject_SetAttr(inst, SWIG_This(), swig_this);
    Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
#else
    PyObject *dict = PyDict_New();
    PyDict_SetItem(dict, SWIG_This(), swig_this);
    inst = PyInstance_NewRaw(data->newargs, dict);
    Py_DECREF(dict);
#endif
  }
  return inst;
#else
#if (PY_VERSION_HEX >= 0x02010000)
  PyObject *inst;
  PyObject *dict = PyDict_New();
  PyDict_SetItem(dict, SWIG_This(), swig_this);
  inst = PyInstance_NewRaw(data->newargs, dict);
  Py_DECREF(dict);
  return (PyObject *) inst;
#else
  PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
  if (inst == NULL) {
    return NULL;
  }
  inst->in_class = (PyClassObject *)data->newargs;
  Py_INCREF(inst->in_class);
  inst->in_dict = PyDict_New();
  if (inst->in_dict == NULL) {
    Py_DECREF(inst);
    return NULL;
  }
#ifdef Py_TPFLAGS_HAVE_WEAKREFS
  inst->in_weakreflist = NULL;
#endif
#ifdef Py_TPFLAGS_GC
  PyObject_GC_Init(inst);
#endif
  PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
  return (PyObject *) inst;
#endif
#endif
}

SWIGRUNTIME void
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
 PyObject *dict;
#if (PY_VERSION_HEX >= 0x02020000) && !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, (char*)"__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,(char*)"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(void *ptr, swig_type_info *type, int flags) {
  if (!ptr) {
    return SWIG_Py_Void();
  } else {
    int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
    PyObject *robj = SwigPyObject_New(ptr, type, own);
    SwigPyClientData *clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
    if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
      PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
      if (inst) {
	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) {
  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 = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
				    (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
    if (PyErr_Occurred()) {
      PyErr_Clear();
      type_pointer = (void *)0;
    }
#endif
  }
  return (swig_module_info *) type_pointer;
}

#if PY_MAJOR_VERSION < 2
/* PyModule_AddObject function was introduced in Python 2.0.  The following function
   is copied out of Python/modsupport.c in python version 2.3.4 */
SWIGINTERN int
PyModule_AddObject(PyObject *m, char *name, PyObject *o)
{
  PyObject *dict;
  if (!PyModule_Check(m)) {
    PyErr_SetString(PyExc_TypeError,
		    "PyModule_AddObject() needs module as first arg");
    return SWIG_ERROR;
  }
  if (!o) {
    PyErr_SetString(PyExc_TypeError,
		    "PyModule_AddObject() needs non-NULL value");
    return SWIG_ERROR;
  }
  
  dict = PyModule_GetDict(m);
  if (dict == NULL) {
    /* Internal error -- modules must have a dict! */
    PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
		 PyModule_GetName(m));
    return SWIG_ERROR;
  }
  if (PyDict_SetItemString(dict, name, o))
    return SWIG_ERROR;
  Py_DECREF(o);
  return SWIG_OK;
}
#endif

SWIGRUNTIME void
SWIG_Python_DestroyModule(void *vptr)
{
  swig_module_info *swig_module = (swig_module_info *) vptr;
  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());
}

SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */

#if PY_VERSION_HEX >= 0x03000000
 /* Add a dummy module object into sys.modules */
  PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
				   swig_empty_runtime_method_table);
#endif
  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
  if (pointer && module) {
    PyModule_AddObject(module, (char*)"type_pointer" 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 *) PyCObject_AsVoidPtr(obj);
  } else {
    swig_module_info *swig_module = SWIG_Python_GetModule();
    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
    if (descriptor) {
      obj = PyCObject_FromVoidPtr(descriptor, 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) {
      char *tmp;
      PyObject *old_str = PyObject_Str(value);
      Py_XINCREF(type);
      PyErr_Clear();
      if (infront) {
	PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
      } else {
	PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), 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 : (char*)"";
}

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 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 __cplusplus
#if 0
{ /* cc-mode */
#endif
}
#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 



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

#define SWIGTYPE_p_char swig_types[0]
#define SWIGTYPE_p_double swig_types[1]
#define SWIGTYPE_p_first_type swig_types[2]
#define SWIGTYPE_p_int swig_types[3]
#define SWIGTYPE_p_int16_t swig_types[4]
#define SWIGTYPE_p_int32_t swig_types[5]
#define SWIGTYPE_p_int64_t swig_types[6]
#define SWIGTYPE_p_mvIMPACT__acquire__AutoControlParameters swig_types[7]
#define SWIGTYPE_p_mvIMPACT__acquire__BasicDeviceSettings swig_types[8]
#define SWIGTYPE_p_mvIMPACT__acquire__BasicDeviceSettingsWithAOI swig_types[9]
#define SWIGTYPE_p_mvIMPACT__acquire__BufferPart swig_types[10]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionBase swig_types[11]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionCameraLink swig_types[12]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionDigital swig_types[13]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionDigitalBase swig_types[14]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionDigitalBase2 swig_types[15]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionManager swig_types[16]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionNonStandard swig_types[17]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionSDI swig_types[18]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionStandard swig_types[19]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraDescriptionStandardBase swig_types[20]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBase swig_types[21]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueCOUGAR swig_types[22]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueDevice swig_types[23]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsBlueFOX swig_types[24]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsFrameGrabber swig_types[25]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsV4L2Device swig_types[26]
#define SWIGTYPE_p_mvIMPACT__acquire__CameraSettingsVirtualDevice swig_types[27]
#define SWIGTYPE_p_mvIMPACT__acquire__ChannelData swig_types[28]
#define SWIGTYPE_p_mvIMPACT__acquire__Component swig_types[29]
#define SWIGTYPE_p_mvIMPACT__acquire__ComponentAccess swig_types[30]
#define SWIGTYPE_p_mvIMPACT__acquire__ComponentCallback swig_types[31]
#define SWIGTYPE_p_mvIMPACT__acquire__ComponentCollection swig_types[32]
#define SWIGTYPE_p_mvIMPACT__acquire__ComponentList swig_types[33]
#define SWIGTYPE_p_mvIMPACT__acquire__ComponentLocator swig_types[34]
#define SWIGTYPE_p_mvIMPACT__acquire__ComponentLocatorBase swig_types[35]
#define SWIGTYPE_p_mvIMPACT__acquire__Connector swig_types[36]
#define SWIGTYPE_p_mvIMPACT__acquire__Device swig_types[37]
#define SWIGTYPE_p_mvIMPACT__acquire__DeviceComponentLocator swig_types[38]
#define SWIGTYPE_p_mvIMPACT__acquire__DeviceManager swig_types[39]
#define SWIGTYPE_p_mvIMPACT__acquire__DigitalIOMeasurementControl swig_types[40]
#define SWIGTYPE_p_mvIMPACT__acquire__DigitalInput swig_types[41]
#define SWIGTYPE_p_mvIMPACT__acquire__DigitalOutput swig_types[42]
#define SWIGTYPE_p_mvIMPACT__acquire__ECantAccessData swig_types[43]
#define SWIGTYPE_p_mvIMPACT__acquire__ECantAllocateNewList swig_types[44]
#define SWIGTYPE_p_mvIMPACT__acquire__ECantRegisterComponent swig_types[45]
#define SWIGTYPE_p_mvIMPACT__acquire__ECantSerializeData swig_types[46]
#define SWIGTYPE_p_mvIMPACT__acquire__EComponent swig_types[47]
#define SWIGTYPE_p_mvIMPACT__acquire__EComponentIDInvalid swig_types[48]
#define SWIGTYPE_p_mvIMPACT__acquire__EComponentNotFound swig_types[49]
#define SWIGTYPE_p_mvIMPACT__acquire__EDeviceManager swig_types[50]
#define SWIGTYPE_p_mvIMPACT__acquire__EImplementationMissing swig_types[51]
#define SWIGTYPE_p_mvIMPACT__acquire__EIncompatibleComponents swig_types[52]
#define SWIGTYPE_p_mvIMPACT__acquire__EInputBufferTooSmall swig_types[53]
#define SWIGTYPE_p_mvIMPACT__acquire__EInvalidFileContent swig_types[54]
#define SWIGTYPE_p_mvIMPACT__acquire__EInvalidInputParameter swig_types[55]
#define SWIGTYPE_p_mvIMPACT__acquire__EInvalidListID swig_types[56]
#define SWIGTYPE_p_mvIMPACT__acquire__EInvalidParameterList swig_types[57]
#define SWIGTYPE_p_mvIMPACT__acquire__EInvalidValue swig_types[58]
#define SWIGTYPE_p_mvIMPACT__acquire__EInvalidValueType swig_types[59]
#define SWIGTYPE_p_mvIMPACT__acquire__EListEntryOccupied swig_types[60]
#define SWIGTYPE_p_mvIMPACT__acquire__EMethod swig_types[61]
#define SWIGTYPE_p_mvIMPACT__acquire__EMethodPtrInvalid swig_types[62]
#define SWIGTYPE_p_mvIMPACT__acquire__ENoModifySizeRights swig_types[63]
#define SWIGTYPE_p_mvIMPACT__acquire__ENoReadRights swig_types[64]
#define SWIGTYPE_p_mvIMPACT__acquire__ENoWriteRights swig_types[65]
#define SWIGTYPE_p_mvIMPACT__acquire__ENotAList swig_types[66]
#define SWIGTYPE_p_mvIMPACT__acquire__ENotAMethod swig_types[67]
#define SWIGTYPE_p_mvIMPACT__acquire__ENotAProperty swig_types[68]
#define SWIGTYPE_p_mvIMPACT__acquire__EProperty swig_types[69]
#define SWIGTYPE_p_mvIMPACT__acquire__EPropertyHandling swig_types[70]
#define SWIGTYPE_p_mvIMPACT__acquire__EPropertyList swig_types[71]
#define SWIGTYPE_p_mvIMPACT__acquire__ESizeMismatch swig_types[72]
#define SWIGTYPE_p_mvIMPACT__acquire__ETranslationTableCorrupted swig_types[73]
#define SWIGTYPE_p_mvIMPACT__acquire__ETranslationTableNotDefined swig_types[74]
#define SWIGTYPE_p_mvIMPACT__acquire__EUnsupportedOperation swig_types[75]
#define SWIGTYPE_p_mvIMPACT__acquire__EUnsupportedParameter swig_types[76]
#define SWIGTYPE_p_mvIMPACT__acquire__EValIDOutOfBounds swig_types[77]
#define SWIGTYPE_p_mvIMPACT__acquire__EValTooLarge swig_types[78]
#define SWIGTYPE_p_mvIMPACT__acquire__EValTooSmall swig_types[79]
#define SWIGTYPE_p_mvIMPACT__acquire__EValidationFailed swig_types[80]
#define SWIGTYPE_p_mvIMPACT__acquire__EWrongParamCount swig_types[81]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t swig_types[82]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_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__TBufferPartDataType_t swig_types[105]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t swig_types[106]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t swig_types[107]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t swig_types[108]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t swig_types[109]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t swig_types[110]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t swig_types[111]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t swig_types[112]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t swig_types[113]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t swig_types[114]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t swig_types[115]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t swig_types[116]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t swig_types[117]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t swig_types[118]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t swig_types[119]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t swig_types[120]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t swig_types[121]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t swig_types[122]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t swig_types[123]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t swig_types[124]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t swig_types[125]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t swig_types[126]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t swig_types[127]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t swig_types[128]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t swig_types[129]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t swig_types[130]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t swig_types[131]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t swig_types[132]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t swig_types[133]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t swig_types[134]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_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__TDeviceEventMode_t swig_types[139]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t swig_types[140]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t swig_types[141]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t swig_types[142]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t swig_types[143]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t swig_types[144]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t swig_types[145]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t swig_types[146]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t swig_types[147]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t swig_types[148]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t swig_types[149]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t swig_types[150]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t swig_types[151]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t swig_types[152]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t swig_types[153]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t swig_types[154]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t swig_types[155]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t swig_types[156]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t swig_types[157]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t swig_types[158]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t swig_types[159]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t swig_types[160]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t swig_types[161]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t swig_types[162]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t swig_types[163]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t swig_types[164]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t swig_types[165]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t swig_types[166]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t swig_types[167]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t swig_types[168]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t swig_types[169]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t swig_types[170]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t swig_types[171]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t swig_types[172]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t swig_types[173]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t swig_types[174]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t swig_types[175]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t swig_types[176]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t swig_types[177]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t swig_types[178]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t swig_types[179]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t swig_types[180]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t swig_types[181]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t swig_types[182]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t swig_types[183]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t swig_types[184]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t swig_types[185]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t swig_types[186]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t swig_types[187]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t swig_types[188]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t swig_types[189]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t swig_types[190]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t swig_types[191]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t swig_types[192]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t swig_types[193]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t swig_types[194]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t swig_types[195]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t swig_types[196]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t swig_types[197]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t swig_types[198]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t swig_types[199]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t swig_types[200]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t swig_types[201]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t swig_types[202]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t swig_types[203]
#define SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t swig_types[204]
#define SWIGTYPE_p_mvIMPACT__acquire__ExceptionFactory swig_types[205]
#define SWIGTYPE_p_mvIMPACT__acquire__FullSettingsBase swig_types[206]
#define SWIGTYPE_p_mvIMPACT__acquire__FunctionInterface swig_types[207]
#define SWIGTYPE_p_mvIMPACT__acquire__GainOffsetKneeChannelParameters swig_types[208]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__AcquisitionControl swig_types[209]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__ActionControl swig_types[210]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__AnalogControl swig_types[211]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__ChunkDataControl swig_types[212]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__ColorTransformationControl swig_types[213]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__CounterAndTimerControl swig_types[214]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__CustomCommandGenerator swig_types[215]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__DataStreamModule 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__FileProtocolAdapter swig_types[223]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__IDevFileStreamBaseT_char_std__char_traitsT_char_t_t 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__ODevFileStreamBaseT_char_std__char_traitsT_char_t_t 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__mvCurrentControl swig_types[240]
#define SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCustomData 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__IOSubSystemBlueCOUGAR swig_types[254]
#define SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemBlueFOX swig_types[255]
#define SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemCommon swig_types[256]
#define SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemFrameGrabber swig_types[257]
#define SWIGTYPE_p_mvIMPACT__acquire__ImageBuffer swig_types[258]
#define SWIGTYPE_p_mvIMPACT__acquire__ImageBufferDesc swig_types[259]
#define SWIGTYPE_p_mvIMPACT__acquire__ImageDestination swig_types[260]
#define SWIGTYPE_p_mvIMPACT__acquire__ImageMemoryManager swig_types[261]
#define SWIGTYPE_p_mvIMPACT__acquire__ImageProcessing swig_types[262]
#define SWIGTYPE_p_mvIMPACT__acquire__ImageRequestControl swig_types[263]
#define SWIGTYPE_p_mvIMPACT__acquire__ImpactAcquireException swig_types[264]
#define SWIGTYPE_p_mvIMPACT__acquire__Info swig_types[265]
#define SWIGTYPE_p_mvIMPACT__acquire__InfoBlueCOUGAR swig_types[266]
#define SWIGTYPE_p_mvIMPACT__acquire__InfoBlueDevice swig_types[267]
#define SWIGTYPE_p_mvIMPACT__acquire__InfoBlueFOX swig_types[268]
#define SWIGTYPE_p_mvIMPACT__acquire__LUTParameters swig_types[269]
#define SWIGTYPE_p_mvIMPACT__acquire__Method swig_types[270]
#define SWIGTYPE_p_mvIMPACT__acquire__MirrorParameters swig_types[271]
#define SWIGTYPE_p_mvIMPACT__acquire__MotorFocusControl swig_types[272]
#define SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorBlueDevice swig_types[273]
#define SWIGTYPE_p_mvIMPACT__acquire__OutputSignalGeneratorFrameGrabber swig_types[274]
#define SWIGTYPE_p_mvIMPACT__acquire__Property swig_types[275]
#define SWIGTYPE_p_mvIMPACT__acquire__PropertyPtr swig_types[276]
#define SWIGTYPE_p_mvIMPACT__acquire__PropertyS swig_types[277]
#define SWIGTYPE_p_mvIMPACT__acquire__PulseStartConfiguration swig_types[278]
#define SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgram swig_types[279]
#define SWIGTYPE_p_mvIMPACT__acquire__RTCtrProgramStep swig_types[280]
#define SWIGTYPE_p_mvIMPACT__acquire__Request swig_types[281]
#define SWIGTYPE_p_mvIMPACT__acquire__RequestFactory swig_types[282]
#define SWIGTYPE_p_mvIMPACT__acquire__RequestInfoConfiguration swig_types[283]
#define SWIGTYPE_p_mvIMPACT__acquire__SettingsBlueFOX swig_types[284]
#define SWIGTYPE_p_mvIMPACT__acquire__SettingsFrameGrabber swig_types[285]
#define SWIGTYPE_p_mvIMPACT__acquire__Statistics swig_types[286]
#define SWIGTYPE_p_mvIMPACT__acquire__SyncOutput swig_types[287]
#define SWIGTYPE_p_mvIMPACT__acquire__SystemBlueFOX swig_types[288]
#define SWIGTYPE_p_mvIMPACT__acquire__SystemSettings swig_types[289]
#define SWIGTYPE_p_mvIMPACT__acquire__SystemV4L2 swig_types[290]
#define SWIGTYPE_p_mvIMPACT__acquire__TAcquisitionField swig_types[291]
#define SWIGTYPE_p_mvIMPACT__acquire__TAcquisitionMode swig_types[292]
#define SWIGTYPE_p_mvIMPACT__acquire__TAcquisitionStartStopBehaviour swig_types[293]
#define SWIGTYPE_p_mvIMPACT__acquire__TAoiMode swig_types[294]
#define SWIGTYPE_p_mvIMPACT__acquire__TAutoControlMode swig_types[295]
#define SWIGTYPE_p_mvIMPACT__acquire__TAutoControlSpeed swig_types[296]
#define SWIGTYPE_p_mvIMPACT__acquire__TAutoExposureControl swig_types[297]
#define SWIGTYPE_p_mvIMPACT__acquire__TAutoGainControl swig_types[298]
#define SWIGTYPE_p_mvIMPACT__acquire__TAutoOffsetCalibration swig_types[299]
#define SWIGTYPE_p_mvIMPACT__acquire__TBayerConversionMode swig_types[300]
#define SWIGTYPE_p_mvIMPACT__acquire__TBayerMosaicParity swig_types[301]
#define SWIGTYPE_p_mvIMPACT__acquire__TBayerWhiteBalanceResult swig_types[302]
#define SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold swig_types[303]
#define SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXFooterMode swig_types[304]
#define SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities swig_types[305]
#define SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed swig_types[306]
#define SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXSensorTiming swig_types[307]
#define SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXTransferSize swig_types[308]
#define SWIGTYPE_p_mvIMPACT__acquire__TBoolean swig_types[309]
#define SWIGTYPE_p_mvIMPACT__acquire__TBufferPartDataType swig_types[310]
#define SWIGTYPE_p_mvIMPACT__acquire__TCameraAoiMode swig_types[311]
#define SWIGTYPE_p_mvIMPACT__acquire__TCameraBinningMode swig_types[312]
#define SWIGTYPE_p_mvIMPACT__acquire__TCameraDataFormat swig_types[313]
#define SWIGTYPE_p_mvIMPACT__acquire__TCameraExposeMode swig_types[314]
#define SWIGTYPE_p_mvIMPACT__acquire__TCameraExternalSyncEdge swig_types[315]
#define SWIGTYPE_p_mvIMPACT__acquire__TCameraExternalSyncOutput swig_types[316]
#define SWIGTYPE_p_mvIMPACT__acquire__TCameraFlashMode swig_types[317]
#define SWIGTYPE_p_mvIMPACT__acquire__TCameraFlashType swig_types[318]
#define SWIGTYPE_p_mvIMPACT__acquire__TCameraHDRMode swig_types[319]
#define SWIGTYPE_p_mvIMPACT__acquire__TCameraInterlacedType swig_types[320]
#define SWIGTYPE_p_mvIMPACT__acquire__TCameraLinkDataValidMode swig_types[321]
#define SWIGTYPE_p_mvIMPACT__acquire__TCameraOutput swig_types[322]
#define SWIGTYPE_p_mvIMPACT__acquire__TCameraPixelClock swig_types[323]
#define SWIGTYPE_p_mvIMPACT__acquire__TCameraScanMode swig_types[324]
#define SWIGTYPE_p_mvIMPACT__acquire__TCameraSerialPortBaudRate swig_types[325]
#define SWIGTYPE_p_mvIMPACT__acquire__TCameraShutterMode swig_types[326]
#define SWIGTYPE_p_mvIMPACT__acquire__TCameraTapsXGeometry swig_types[327]
#define SWIGTYPE_p_mvIMPACT__acquire__TCameraTapsYGeometry swig_types[328]
#define SWIGTYPE_p_mvIMPACT__acquire__TCameraTestMode swig_types[329]
#define SWIGTYPE_p_mvIMPACT__acquire__TCameraTriggerMode swig_types[330]
#define SWIGTYPE_p_mvIMPACT__acquire__TCameraTriggerSource swig_types[331]
#define SWIGTYPE_p_mvIMPACT__acquire__TChannelSplitMode swig_types[332]
#define SWIGTYPE_p_mvIMPACT__acquire__TClampMode swig_types[333]
#define SWIGTYPE_p_mvIMPACT__acquire__TColorProcessingMode swig_types[334]
#define SWIGTYPE_p_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode swig_types[335]
#define SWIGTYPE_p_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode swig_types[336]
#define SWIGTYPE_p_mvIMPACT__acquire__TDarkCurrentFilterMode swig_types[337]
#define SWIGTYPE_p_mvIMPACT__acquire__TDefectivePixelsFilterMode swig_types[338]
#define SWIGTYPE_p_mvIMPACT__acquire__TDeviceAccessMode swig_types[339]
#define SWIGTYPE_p_mvIMPACT__acquire__TDeviceAdvancedOptions swig_types[340]
#define SWIGTYPE_p_mvIMPACT__acquire__TDeviceCapability swig_types[341]
#define SWIGTYPE_p_mvIMPACT__acquire__TDeviceClass swig_types[342]
#define SWIGTYPE_p_mvIMPACT__acquire__TDeviceDigitalOutputMode swig_types[343]
#define SWIGTYPE_p_mvIMPACT__acquire__TDeviceEventMode swig_types[344]
#define SWIGTYPE_p_mvIMPACT__acquire__TDeviceEventType swig_types[345]
#define SWIGTYPE_p_mvIMPACT__acquire__TDeviceImageTrigger swig_types[346]
#define SWIGTYPE_p_mvIMPACT__acquire__TDeviceInterfaceLayout swig_types[347]
#define SWIGTYPE_p_mvIMPACT__acquire__TDeviceLoadSettings swig_types[348]
#define SWIGTYPE_p_mvIMPACT__acquire__TDevicePowerMode swig_types[349]
#define SWIGTYPE_p_mvIMPACT__acquire__TDeviceScanRateMode swig_types[350]
#define SWIGTYPE_p_mvIMPACT__acquire__TDeviceSignalOutputStartEvent swig_types[351]
#define SWIGTYPE_p_mvIMPACT__acquire__TDeviceState swig_types[352]
#define SWIGTYPE_p_mvIMPACT__acquire__TDeviceSyncOutMode swig_types[353]
#define SWIGTYPE_p_mvIMPACT__acquire__TDeviceTriggerInterface swig_types[354]
#define SWIGTYPE_p_mvIMPACT__acquire__TDeviceTriggerMode swig_types[355]
#define SWIGTYPE_p_mvIMPACT__acquire__TDeviceTriggerOverlap swig_types[356]
#define SWIGTYPE_p_mvIMPACT__acquire__TDigIOState swig_types[357]
#define SWIGTYPE_p_mvIMPACT__acquire__TDigitalIOMeasurementMode swig_types[358]
#define SWIGTYPE_p_mvIMPACT__acquire__TDigitalIOMeasurementSource swig_types[359]
#define SWIGTYPE_p_mvIMPACT__acquire__TDigitalOutputControlMode swig_types[360]
#define SWIGTYPE_p_mvIMPACT__acquire__TDigitalSignal swig_types[361]
#define SWIGTYPE_p_mvIMPACT__acquire__TFieldGateMode swig_types[362]
#define SWIGTYPE_p_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode swig_types[363]
#define SWIGTYPE_p_mvIMPACT__acquire__TFlatFieldFilterMode swig_types[364]
#define SWIGTYPE_p_mvIMPACT__acquire__THWUpdateResult swig_types[365]
#define SWIGTYPE_p_mvIMPACT__acquire__TI2COperationMode swig_types[366]
#define SWIGTYPE_p_mvIMPACT__acquire__TI2COperationStatus swig_types[367]
#define SWIGTYPE_p_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode swig_types[368]
#define SWIGTYPE_p_mvIMPACT__acquire__TImageBufferPixelFormat swig_types[369]
#define SWIGTYPE_p_mvIMPACT__acquire__TImageDestinationPixelFormat swig_types[370]
#define SWIGTYPE_p_mvIMPACT__acquire__TImageProcessingFilter swig_types[371]
#define SWIGTYPE_p_mvIMPACT__acquire__TImageProcessingMode swig_types[372]
#define SWIGTYPE_p_mvIMPACT__acquire__TImageProcessingOptimization swig_types[373]
#define SWIGTYPE_p_mvIMPACT__acquire__TImageProcessingResult swig_types[374]
#define SWIGTYPE_p_mvIMPACT__acquire__TImageRequestControlMode swig_types[375]
#define SWIGTYPE_p_mvIMPACT__acquire__TInfoSensorColorMode swig_types[376]
#define SWIGTYPE_p_mvIMPACT__acquire__TInfoSensorType swig_types[377]
#define SWIGTYPE_p_mvIMPACT__acquire__TInterlacedMode swig_types[378]
#define SWIGTYPE_p_mvIMPACT__acquire__TLUTGammaMode swig_types[379]
#define SWIGTYPE_p_mvIMPACT__acquire__TLUTImplementation swig_types[380]
#define SWIGTYPE_p_mvIMPACT__acquire__TLUTInterpolationMode swig_types[381]
#define SWIGTYPE_p_mvIMPACT__acquire__TLUTMapping swig_types[382]
#define SWIGTYPE_p_mvIMPACT__acquire__TLUTMode swig_types[383]
#define SWIGTYPE_p_mvIMPACT__acquire__TLineCounter swig_types[384]
#define SWIGTYPE_p_mvIMPACT__acquire__TMemoryManagerMode swig_types[385]
#define SWIGTYPE_p_mvIMPACT__acquire__TMemoryManagerPoolMode swig_types[386]
#define SWIGTYPE_p_mvIMPACT__acquire__TMirrorMode swig_types[387]
#define SWIGTYPE_p_mvIMPACT__acquire__TMirrorOperationMode swig_types[388]
#define SWIGTYPE_p_mvIMPACT__acquire__TOnBoardMemoryMode swig_types[389]
#define SWIGTYPE_p_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode swig_types[390]
#define SWIGTYPE_p_mvIMPACT__acquire__TPolarizedDataExtractionMode swig_types[391]
#define SWIGTYPE_p_mvIMPACT__acquire__TPulseStartTrigger swig_types[392]
#define SWIGTYPE_p_mvIMPACT__acquire__TRTCtrlModes swig_types[393]
#define SWIGTYPE_p_mvIMPACT__acquire__TRTProgOpCodes swig_types[394]
#define SWIGTYPE_p_mvIMPACT__acquire__TRequestImageMemoryMode swig_types[395]
#define SWIGTYPE_p_mvIMPACT__acquire__TRequestResult swig_types[396]
#define SWIGTYPE_p_mvIMPACT__acquire__TRequestState swig_types[397]
#define SWIGTYPE_p_mvIMPACT__acquire__TScalerInterpolationMode swig_types[398]
#define SWIGTYPE_p_mvIMPACT__acquire__TScalerMode swig_types[399]
#define SWIGTYPE_p_mvIMPACT__acquire__TScanClock swig_types[400]
#define SWIGTYPE_p_mvIMPACT__acquire__TScanStandard swig_types[401]
#define SWIGTYPE_p_mvIMPACT__acquire__TThreadPriority swig_types[402]
#define SWIGTYPE_p_mvIMPACT__acquire__TTriggerMoment swig_types[403]
#define SWIGTYPE_p_mvIMPACT__acquire__TUserDataAccessRight swig_types[404]
#define SWIGTYPE_p_mvIMPACT__acquire__TUserDataReconnectBehaviour swig_types[405]
#define SWIGTYPE_p_mvIMPACT__acquire__TVideoStandard swig_types[406]
#define SWIGTYPE_p_mvIMPACT__acquire__TVirtualDeviceImageType swig_types[407]
#define SWIGTYPE_p_mvIMPACT__acquire__TVirtualDeviceTestMode swig_types[408]
#define SWIGTYPE_p_mvIMPACT__acquire__TWhiteBalanceCalibrationMode swig_types[409]
#define SWIGTYPE_p_mvIMPACT__acquire__TWhiteBalanceParameter swig_types[410]
#define SWIGTYPE_p_mvIMPACT__acquire__TriggerControl swig_types[411]
#define SWIGTYPE_p_mvIMPACT__acquire__UserData swig_types[412]
#define SWIGTYPE_p_mvIMPACT__acquire__UserDataEntry swig_types[413]
#define SWIGTYPE_p_mvIMPACT__acquire__WhiteBalanceSettings swig_types[414]
#define SWIGTYPE_p_p_mvIMPACT__acquire__Request swig_types[415]
#define SWIGTYPE_p_second_type swig_types[416]
#define SWIGTYPE_p_std__ios_base__openmode swig_types[417]
#define SWIGTYPE_p_std__pairT_std__string_double_t swig_types[418]
#define SWIGTYPE_p_std__pairT_std__string_int_t swig_types[419]
#define SWIGTYPE_p_std__runtime_error swig_types[420]
#define SWIGTYPE_p_std__streamsize swig_types[421]
#define SWIGTYPE_p_std__vectorT_int64_t_t swig_types[422]
#define SWIGTYPE_p_std__vectorT_mvIMPACT__acquire__Component_t swig_types[423]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_int64_t_t_t swig_types[424]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t_t swig_types[425]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t_t swig_types[426]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t_t swig_types[427]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t_t swig_types[428]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t_t swig_types[429]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t_t swig_types[430]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t_t swig_types[431]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t_t swig_types[432]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t_t swig_types[433]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t_t swig_types[434]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t_t swig_types[435]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t_t swig_types[436]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t_t swig_types[437]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t_t swig_types[438]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t_t swig_types[439]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t_t swig_types[440]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t_t swig_types[441]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t_t swig_types[442]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t_t swig_types[443]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t_t swig_types[444]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t_t swig_types[445]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t_t swig_types[446]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t_t swig_types[447]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t_t swig_types[448]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t_t swig_types[449]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t_t swig_types[450]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t_t swig_types[451]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t_t swig_types[452]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t_t swig_types[453]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t_t swig_types[454]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t_t swig_types[455]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t_t swig_types[456]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t_t swig_types[457]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t_t swig_types[458]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t_t swig_types[459]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t_t swig_types[460]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t_t swig_types[461]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t_t swig_types[462]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t_t swig_types[463]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t_t swig_types[464]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t_t swig_types[465]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t_t swig_types[466]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t_t swig_types[467]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t_t swig_types[468]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t_t swig_types[469]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t_t swig_types[470]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t_t swig_types[471]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t_t swig_types[472]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t_t swig_types[473]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t_t swig_types[474]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t_t swig_types[475]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t_t swig_types[476]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t_t swig_types[477]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceEventMode_t_t swig_types[478]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceEventType_t_t swig_types[479]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t_t swig_types[480]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t_t swig_types[481]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t_t swig_types[482]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t_t swig_types[483]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t_t swig_types[484]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t_t swig_types[485]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t_t swig_types[486]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t_t swig_types[487]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t_t swig_types[488]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t_t swig_types[489]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t_t swig_types[490]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t_t swig_types[491]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t_t swig_types[492]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t_t swig_types[493]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t_t swig_types[494]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t_t swig_types[495]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t_t swig_types[496]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t_t swig_types[497]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t_t swig_types[498]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t_t swig_types[499]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t_t swig_types[500]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t_t swig_types[501]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t_t swig_types[502]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t_t swig_types[503]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t_t swig_types[504]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t_t swig_types[505]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t_t swig_types[506]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t_t swig_types[507]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t_t swig_types[508]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t_t swig_types[509]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t_t swig_types[510]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t_t swig_types[511]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t_t swig_types[512]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t_t swig_types[513]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t_t swig_types[514]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t_t swig_types[515]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t_t swig_types[516]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t_t swig_types[517]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t_t swig_types[518]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t_t swig_types[519]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t_t swig_types[520]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t_t swig_types[521]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t_t swig_types[522]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t_t swig_types[523]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t_t swig_types[524]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t_t swig_types[525]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t_t swig_types[526]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t_t swig_types[527]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t_t swig_types[528]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t_t swig_types[529]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t_t swig_types[530]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t_t swig_types[531]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t_t swig_types[532]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t_t swig_types[533]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t_t swig_types[534]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t_t swig_types[535]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TThreadPriority_t_t swig_types[536]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t_t swig_types[537]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t_t swig_types[538]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t_t swig_types[539]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t_t swig_types[540]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t_t swig_types[541]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t_t swig_types[542]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t_t swig_types[543]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t_t swig_types[544]
#define SWIGTYPE_p_std__vectorT_std__string_t swig_types[545]
#define SWIGTYPE_p_std__vectorT_void_p_t swig_types[546]
#define SWIGTYPE_p_uint16_t swig_types[547]
#define SWIGTYPE_p_uint32_t swig_types[548]
#define SWIGTYPE_p_uint64_t swig_types[549]
#define SWIGTYPE_p_void swig_types[550]
static swig_type_info *swig_types[552];
static swig_module_info swig_module = {swig_types, 551, 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) -------- */

#if (PY_VERSION_HEX <= 0x02000000)
# if !defined(SWIG_PYTHON_CLASSIC)
#  error "This python version requires swig to be run with the '-classic' option"
# endif
#endif
#if (PY_VERSION_HEX <= 0x02020000)
# error "This python version requires swig to be run with the '-nomodern' option"
#endif
#if (PY_VERSION_HEX <= 0x02020000)
# error "This python version requires swig to be run with the '-nomodernargs' option"
#endif
#ifndef METH_O
# error "This python version requires swig to be run with the '-nofastunpack' option"
#endif

/*-----------------------------------------------
              @(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 0x010341 
#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)
    {
      Py_XINCREF(_obj);      
    }
    
    SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
    {
      if (initial_ref) {
        Py_XINCREF(_obj);
      }
    }
    
    SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) 
    {
      Py_XINCREF(item._obj);
      Py_XDECREF(_obj);
      _obj = item._obj;
      return *this;      
    }
    
    ~SwigPtr_PyObject() 
    {
      Py_XDECREF(_obj);
    }
    
    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 <string>


#include <stdexcept>


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


#include <string>
#include <stdexcept>


#include <utility>


#define MVIMPACT_USE_NAMESPACES
#include "mvIMPACT_acquire_GenICam_CustomCommands.h"
#include "mvIMPACT_acquire_GenICam_FileStream.h"
#ifdef _MSC_VER // is Microsoft compiler?
#   include "mvIMPACT_acquire_display.h"
#endif // #ifdef _MSC_VER // is Microsoft compiler?


template<typename T> T PyObjectToC (PyObject* p) { return (T) PyInt_AsLong(p); };

template<> float       PyObjectToC<float>       (PyObject* p) { return (float) PyFloat_AsDouble(p); };
template<> double      PyObjectToC<double>      (PyObject* p) { return         PyFloat_AsDouble(p); };
template<> std::string PyObjectToC<std::string> (PyObject* p) { return std::string(PyString_AsString(p)); };

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()); };

// Template to check if a Python object can be converted into a given C type
// Visual Studio used to accept only return values of type int
// #ifdef __GNUC__
template<typename T> bool PyTypeCheck( PyObject* p ) { return PyNumber_Check(p); }
// #else
// template<typename T> int PyTypeCheck( PyObject* p ) { return PyNumber_Check(p); }
// #endif
template<> bool PyTypeCheck<std::string>( PyObject* p ) { return PyString_Check(p); }


static void
handleImpactAcquireException(const mvIMPACT::acquire::ImpactAcquireException &e) {
   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));
}


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 (PyUnicode_Check(obj))
#else  
  if (PyString_Check(obj))
#endif
  {
    char *cstr; Py_ssize_t len;
#if PY_VERSION_HEX>=0x03000000
    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);
    PyBytes_AsStringAndSize(obj, &cstr, &len);
    if(alloc) *alloc = SWIG_NEWOBJ;
#else
    PyString_AsStringAndSize(obj, &cstr, &len);
#endif
    if (cptr) {
      if (alloc) {
	/* 
	   In python the user should not be able to modify the inner
	   string representation. To warranty that, if you define
	   SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
	   buffer is always returned.

	   The default behavior is just to return the pointer value,
	   so, be careful.
	*/ 
#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
	if (*alloc != SWIG_OLDOBJ) 
#else
	if (*alloc == SWIG_NEWOBJ) 
#endif
	  {
	    *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
        assert(0); /* Should never reach here in Python 3 */
        #endif
	*cptr = SWIG_Python_str_AsChar(obj);
      }
    }
    if (psize) *psize = len + 1;
#if PY_VERSION_HEX>=0x03000000
    Py_XDECREF(obj);
#endif
    return SWIG_OK;
  } else {
    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_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;
}


#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


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;
  } else if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AsLong(obj);
    return SWIG_OK;
  } 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_long (PyObject *obj, long* val)
{
  if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AsLong(obj);
    return SWIG_OK;
  } else if (PyLong_Check(obj)) {
    long v = PyLong_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
    }
  }
#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;
}


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 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;
}


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_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
    } else {
#if PY_VERSION_HEX >= 0x03000000
      return PyUnicode_FromStringAndSize(carray, static_cast< int >(size));
#else
      return PyString_FromStringAndSize(carray, static_cast< int >(size));
#endif
    }
  } else {
    return SWIG_Py_Void();
  }
}


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


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;
    }
  };

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

  /*
    Partial specialization for pointers
  */
  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_NewPointerObj(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;
      int res = SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0);
      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, bool throw_error) {
      Type v;
      int res = asval(obj, &v);
      if (!obj || !SWIG_IsOK(res)) {
	if (!PyErr_Occurred()) {
	  ::SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	if (throw_error) throw std::invalid_argument("bad type");
      }
      return v;
    }
  };

  template <class Type> 
  struct traits_as<Type, pointer_category> {
    static Type as(PyObject *obj, bool throw_error) {
      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 {
	// Uninitialized return value, no Type() constructor required.
	static Type *v_def = (Type*) malloc(sizeof(Type));
	if (!PyErr_Occurred()) {
	  SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	if (throw_error) throw std::invalid_argument("bad type");
	memset(v_def,0,sizeof(Type));
	return *v_def;
      }
    }
  };

  template <class Type> 
  struct traits_as<Type*, pointer_category> {
    static Type* as(PyObject *obj, bool throw_error) {
      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>());
	}
	if (throw_error) throw std::invalid_argument("bad type");
	return 0;
      }
    }
  };
    
  template <class Type>
  inline Type as(PyObject *obj, bool te = false) {
    return traits_as<Type, typename traits<Type>::category>::as(obj, te);
  }

  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);
    }
  };
}


  #define SWIG_From_long   PyInt_FromLong 


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


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)) return res1;
	  U *psecond = &(vp->second);
	  int res2 = swig::asval((PyObject*)second, psecond);
	  if (!SWIG_IsOK(res2)) 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;
	  res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<value_type>(),0);
	  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" " >";
	  }
	};
      }
    

  #define SWIG_From_double   PyFloat_FromDouble 


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

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


SWIGINTERNINLINE PyObject* 
SWIG_From_unsigned_SS_long  (unsigned long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value)); 
}


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


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)) {
    if ((csize == size + 1) && cptr && !(cptr[csize-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;
}

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 = PyObject_IsTrue(obj);
  if (r == -1)
    return SWIG_ERROR;
  if (val) *val = r ? true : false;
  return SWIG_OK;
}





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


SWIGINTERN int
SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
{
  if (PyInt_Check(obj)) {
    long v = PyInt_AsLong(obj);
    if (v >= 0) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      return SWIG_OverflowError;
    }
  } else if (PyLong_Check(obj)) {
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
    }
  }
#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;
}


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 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];
    }
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *_wrap_new_pairstringint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,int > *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { result = (std::pair< std::string,int > *)new std::pair< std::string,int >(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (std::pair< std::string,int > *)new std::pair< std::string,int >(arg1,arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (std::pair< std::string,int > *)new std::pair< std::string,int >((std::pair< std::string,int > const &)*arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_pairstringint",0,2,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_pairstringint__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_pairstringint__SWIG_2(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_pairstringint__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_pairstringint'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,int >()\n"
  "    std::pair< std::string,int >(std::string,int)\n"
  "    std::pair< std::string,int >(std::pair< std::string,int > const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_pairstringdouble__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; std::pair< std::string,double > *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { result = (std::pair< std::string,double > *)new std::pair< std::string,double >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (std::pair< std::string,double > *)new std::pair< std::string,double >(arg1,arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (std::pair< std::string,double > *)new std::pair< std::string,double >((std::pair< std::string,double > const &)*arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_pairstringdouble",0,2,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_pairstringdouble__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_pairstringdouble__SWIG_2(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_pairstringdouble__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_pairstringdouble'.\n"
  "  Possible C/C++ prototypes are:\n" "    std::pair< std::string,double >()\n"
  "    std::pair< std::string,double >(std::string,double)\n"
  "    std::pair< std::string,double >(std::pair< std::string,double > const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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 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_PROP_MAX_VAL_set(PyObject *) { SWIG_Error(SWIG_AttributeError,"Variable PROP_MAX_VAL is read-only.");
  return 1; }
SWIGINTERN PyObject *Swig_var_PROP_MAX_VAL_get(void) { PyObject *pyobj = 0;
  pyobj = SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROP_MAX_VAL)); return pyobj; }
SWIGINTERN int Swig_var_PROP_MIN_VAL_set(PyObject *) { SWIG_Error(SWIG_AttributeError,"Variable PROP_MIN_VAL is read-only.");
  return 1; }
SWIGINTERN PyObject *Swig_var_PROP_MIN_VAL_get(void) { PyObject *pyobj = 0;
  pyobj = SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROP_MIN_VAL)); return pyobj; }
SWIGINTERN int Swig_var_PROP_STEP_WIDTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PROP_STEP_WIDTH is read-only."); return 1; }
SWIGINTERN PyObject *Swig_var_PROP_STEP_WIDTH_get(void) { PyObject *pyobj = 0;
  pyobj = SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROP_STEP_WIDTH)); return pyobj; }
SWIGINTERN int Swig_var_PROP_DEFAULT_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PROP_DEFAULT_VALUE is read-only."); return 1; }
SWIGINTERN PyObject *Swig_var_PROP_DEFAULT_VALUE_get(void) { PyObject *pyobj = 0;
  pyobj = SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROP_DEFAULT_VALUE)); return pyobj; }
SWIGINTERN int Swig_var_PROP_MAX_BINARY_BUFFER_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PROP_MAX_BINARY_BUFFER_SIZE is read-only."); return 1; }
SWIGINTERN PyObject *Swig_var_PROP_MAX_BINARY_BUFFER_SIZE_get(void) { PyObject *pyobj = 0;
  pyobj = SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROP_MAX_BINARY_BUFFER_SIZE)); return pyobj; }
SWIGINTERN int Swig_var_PROP_LAST_CONSTANT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PROP_LAST_CONSTANT is read-only."); return 1; }
SWIGINTERN PyObject *Swig_var_PROP_LAST_CONSTANT_get(void) { PyObject *pyobj = 0;
  pyobj = SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROP_LAST_CONSTANT)); return pyobj; }
SWIGINTERN int Swig_var_DEFAULT_STRING_SIZE_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DEFAULT_STRING_SIZE_LIMIT is read-only."); return 1; }
SWIGINTERN PyObject *Swig_var_DEFAULT_STRING_SIZE_LIMIT_get(void) { PyObject *pyobj = 0;
  pyobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(mvIMPACT::acquire::DEFAULT_STRING_SIZE_LIMIT)); 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[mvIMPACT::acquire::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, mvIMPACT::acquire::DEFAULT_STRING_SIZE_LIMIT); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ChannelData_szChannelDesc_set" "', argument " "2"" of type '" "char [mvIMPACT::acquire::DEFAULT_STRING_SIZE_LIMIT]""'"); }
   arg2 = reinterpret_cast< char * >(temp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg2) memcpy(arg1->szChannelDesc,arg2,mvIMPACT::acquire::DEFAULT_STRING_SIZE_LIMIT*sizeof(char));
    else memset(arg1->szChannelDesc,0,mvIMPACT::acquire::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 = mvIMPACT::acquire::DEFAULT_STRING_SIZE_LIMIT; while (size && (result[size - 1] == '\0')) --size;
    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; {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { result = (mvIMPACT::acquire::ChannelData *)new mvIMPACT::acquire::ChannelData(); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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; {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { result = (mvIMPACT::acquire::ImageBuffer *)new mvIMPACT::acquire::ImageBuffer(); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ImpactAcquireException *)new mvIMPACT::acquire::ImpactAcquireException((std::string const &)*arg1,(std::string const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::ImpactAcquireException const *)arg1)->getErrorString(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::ImpactAcquireException const *)arg1)->getErrorCode(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImpactAcquireException_getErrorCodeAsString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::ImpactAcquireException const *)arg1)->getErrorCodeAsString(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = mvIMPACT::acquire::ImpactAcquireException::getErrorCodeAsString(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ImpactAcquireException_getErrorCodeAsString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[2];
  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) {
    return _wrap_ImpactAcquireException_getErrorCodeAsString__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ImpactAcquireException_getErrorCodeAsString'.\n"
  "  Possible C/C++ prototypes are:\n" "    getErrorCodeAsString(mvIMPACT::acquire::ImpactAcquireException const *)\n"
  "    mvIMPACT::acquire::ImpactAcquireException::getErrorCodeAsString(int)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::ImpactAcquireException const *)arg1)->getErrorOrigin(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (PyObject *)mvIMPACT_acquire_ImpactAcquireException_getArgs((mvIMPACT::acquire::ImpactAcquireException const *)arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (char *)mvIMPACT_acquire_ImpactAcquireException___str__((mvIMPACT::acquire::ImpactAcquireException const *)arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EDeviceManager *)new mvIMPACT::acquire::EDeviceManager((std::string const &)*arg1,(std::string const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EPropertyHandling *)new mvIMPACT::acquire::EPropertyHandling((std::string const &)*arg1,(std::string const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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,(char*)"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(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::ENotAList *result = 0 ; if (!SWIG_Python_UnpackTuple(args,"new_ENotAList",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_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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ENotAList *)new mvIMPACT::acquire::ENotAList((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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(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::ENotAProperty *result = 0 ; if (!SWIG_Python_UnpackTuple(args,"new_ENotAProperty",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_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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ENotAProperty *)new mvIMPACT::acquire::ENotAProperty((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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(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::ENotAMethod *result = 0 ; if (!SWIG_Python_UnpackTuple(args,"new_ENotAMethod",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_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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ENotAMethod *)new mvIMPACT::acquire::ENotAMethod((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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(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::ENoReadRights *result = 0 ; if (!SWIG_Python_UnpackTuple(args,"new_ENoReadRights",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_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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ENoReadRights *)new mvIMPACT::acquire::ENoReadRights((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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(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::ENoWriteRights *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args,"new_ENoWriteRights",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_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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ENoWriteRights *)new mvIMPACT::acquire::ENoWriteRights((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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(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::ENoModifySizeRights *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args,"new_ENoModifySizeRights",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_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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ENoModifySizeRights *)new mvIMPACT::acquire::ENoModifySizeRights((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EIncompatibleComponents *)new mvIMPACT::acquire::EIncompatibleComponents((std::string const &)*arg1,(std::string const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EIncompatibleComponents *)new mvIMPACT::acquire::EIncompatibleComponents((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_EIncompatibleComponents",0,3,argv))) SWIG_fail; --argc; if (argc == 2) {
    return _wrap_new_EIncompatibleComponents__SWIG_1(self, argc, argv);}  if (argc == 3) {
    return _wrap_new_EIncompatibleComponents__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EIncompatibleComponents'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EIncompatibleComponents(std::string const &,std::string const &,bool)\n"
  "    mvIMPACT::acquire::EIncompatibleComponents(std::string const &,std::string const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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,(char*)"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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EInvalidValue *)new mvIMPACT::acquire::EInvalidValue((std::string const &)*arg1,(std::string const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EInvalidValue *)new mvIMPACT::acquire::EInvalidValue((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_EInvalidValue",0,3,argv))) SWIG_fail; --argc; if (argc == 2) {
    return _wrap_new_EInvalidValue__SWIG_1(self, argc, argv);}  if (argc == 3) {
    return _wrap_new_EInvalidValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EInvalidValue'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EInvalidValue(std::string const &,std::string const &,bool)\n"
  "    mvIMPACT::acquire::EInvalidValue(std::string const &,std::string const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EValIDOutOfBounds *)new mvIMPACT::acquire::EValIDOutOfBounds((std::string const &)*arg1,(std::string const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EValIDOutOfBounds *)new mvIMPACT::acquire::EValIDOutOfBounds((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_EValIDOutOfBounds",0,3,argv))) SWIG_fail; --argc; if (argc == 2) {
    return _wrap_new_EValIDOutOfBounds__SWIG_1(self, argc, argv);}  if (argc == 3) {
    return _wrap_new_EValIDOutOfBounds__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EValIDOutOfBounds'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EValIDOutOfBounds(std::string const &,std::string const &,bool)\n"
  "    mvIMPACT::acquire::EValIDOutOfBounds(std::string const &,std::string const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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(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::ETranslationTableCorrupted *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args,"new_ETranslationTableCorrupted",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_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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ETranslationTableCorrupted *)new mvIMPACT::acquire::ETranslationTableCorrupted((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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(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::ETranslationTableNotDefined *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args,"new_ETranslationTableNotDefined",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_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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ETranslationTableNotDefined *)new mvIMPACT::acquire::ETranslationTableNotDefined((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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(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::EInvalidValueType *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args,"new_EInvalidValueType",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_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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EInvalidValueType *)new mvIMPACT::acquire::EInvalidValueType((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EValTooLarge *)new mvIMPACT::acquire::EValTooLarge((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EValTooLarge *)new mvIMPACT::acquire::EValTooLarge((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_EValTooLarge",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    return _wrap_new_EValTooLarge__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_new_EValTooLarge__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EValTooLarge'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EValTooLarge(std::string const &,std::string const &)\n"
  "    mvIMPACT::acquire::EValTooLarge(std::string const &,std::string const &,std::string const &,std::string const &)\n");
  return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EValTooSmall *)new mvIMPACT::acquire::EValTooSmall((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EValTooSmall *)new mvIMPACT::acquire::EValTooSmall((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_EValTooSmall",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    return _wrap_new_EValTooSmall__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_new_EValTooSmall__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EValTooSmall'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EValTooSmall(std::string const &,std::string const &)\n"
  "    mvIMPACT::acquire::EValTooSmall(std::string const &,std::string const &,std::string const &,std::string const &)\n");
  return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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(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::EValidationFailed *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args,"new_EValidationFailed",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_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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EValidationFailed *)new mvIMPACT::acquire::EValidationFailed((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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,(char*)"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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EComponentNotFound *)new mvIMPACT::acquire::EComponentNotFound((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EListEntryOccupied *)new mvIMPACT::acquire::EListEntryOccupied((std::string const &)*arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EComponentIDInvalid *)new mvIMPACT::acquire::EComponentIDInvalid((std::string const &)*arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EInvalidListID *)new mvIMPACT::acquire::EInvalidListID((std::string const &)*arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EInvalidListID *)new mvIMPACT::acquire::EInvalidListID((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_EInvalidListID",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_EInvalidListID__SWIG_0(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_EInvalidListID__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EInvalidListID'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EInvalidListID(std::string const &)\n"
  "    mvIMPACT::acquire::EInvalidListID(std::string const &,std::string const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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(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::ECantAccessData *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args,"new_ECantAccessData",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_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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ECantAccessData *)new mvIMPACT::acquire::ECantAccessData((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ECantRegisterComponent *)new mvIMPACT::acquire::ECantRegisterComponent((std::string const &)*arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ECantRegisterComponent *)new mvIMPACT::acquire::ECantRegisterComponent((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ECantRegisterComponent",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_ECantRegisterComponent__SWIG_0(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_ECantRegisterComponent__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ECantRegisterComponent'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::ECantRegisterComponent(std::string const &)\n"
  "    mvIMPACT::acquire::ECantRegisterComponent(std::string const &,std::string const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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,(char*)"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(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::EMethodPtrInvalid *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args,"new_EMethodPtrInvalid",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_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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EMethodPtrInvalid *)new mvIMPACT::acquire::EMethodPtrInvalid((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EInvalidParameterList *)new mvIMPACT::acquire::EInvalidParameterList((std::string const &)*arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EInvalidParameterList *)new mvIMPACT::acquire::EInvalidParameterList((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_EInvalidParameterList",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_EInvalidParameterList__SWIG_0(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_EInvalidParameterList__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EInvalidParameterList'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EInvalidParameterList(std::string const &)\n"
  "    mvIMPACT::acquire::EInvalidParameterList(std::string const &,std::string const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EUnsupportedParameter *)new mvIMPACT::acquire::EUnsupportedParameter((std::string const &)*arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ESizeMismatch *)new mvIMPACT::acquire::ESizeMismatch((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EImplementationMissing *)new mvIMPACT::acquire::EImplementationMissing((std::string const &)*arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EImplementationMissing *)new mvIMPACT::acquire::EImplementationMissing((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_EImplementationMissing",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_EImplementationMissing__SWIG_0(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_EImplementationMissing__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EImplementationMissing'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EImplementationMissing(std::string const &)\n"
  "    mvIMPACT::acquire::EImplementationMissing(std::string const &,std::string const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EInvalidInputParameter *)new mvIMPACT::acquire::EInvalidInputParameter((std::string const &)*arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EInvalidInputParameter *)new mvIMPACT::acquire::EInvalidInputParameter((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_EInvalidInputParameter",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_EInvalidInputParameter__SWIG_0(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_EInvalidInputParameter__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EInvalidInputParameter'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EInvalidInputParameter(std::string const &)\n"
  "    mvIMPACT::acquire::EInvalidInputParameter(std::string const &,std::string const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EInputBufferTooSmall *)new mvIMPACT::acquire::EInputBufferTooSmall((std::string const &)*arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EWrongParamCount *)new mvIMPACT::acquire::EWrongParamCount((std::string const &)*arg1); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EWrongParamCount *)new mvIMPACT::acquire::EWrongParamCount((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_EWrongParamCount",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_EWrongParamCount__SWIG_0(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_EWrongParamCount__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EWrongParamCount'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EWrongParamCount(std::string const &)\n"
  "    mvIMPACT::acquire::EWrongParamCount(std::string const &,std::string const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EUnsupportedOperation *)new mvIMPACT::acquire::EUnsupportedOperation((std::string const &)*arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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(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::ECantSerializeData *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args,"new_ECantSerializeData",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_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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ECantSerializeData *)new mvIMPACT::acquire::ECantSerializeData((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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(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::EInvalidFileContent *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args,"new_EInvalidFileContent",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_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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EInvalidFileContent *)new mvIMPACT::acquire::EInvalidFileContent((std::string const &)*arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ECantAllocateNewList *)new mvIMPACT::acquire::ECantAllocateNewList((std::string const &)*arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try { result = mvIMPACT::acquire::ExceptionFactory::getLastErrorString(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        mvIMPACT::acquire::ExceptionFactory::raiseException((char const *)arg1,arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        mvIMPACT::acquire::ExceptionFactory::raiseException((char const *)arg1,arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        mvIMPACT::acquire::ExceptionFactory::raiseException((char const *)arg1,arg2,arg3,(std::string const &)*arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"ExceptionFactory_raiseException",0,4,argv))) SWIG_fail; --argc; if (argc == 3) {
    return _wrap_ExceptionFactory_raiseException__SWIG_1(self, argc, argv);}  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) {
    return _wrap_ExceptionFactory_raiseException__SWIG_2(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ExceptionFactory_raiseException'.\n"
  "  Possible C/C++ prototypes are:\n" "    raiseException(char const *,int,int,mvIMPACT::acquire::HOBJ)\n"
  "    raiseException(char const *,int,int)\n"
  "    mvIMPACT::acquire::ExceptionFactory::raiseException(char const *,int,mvIMPACT::acquire::TDMR_ERROR,std::string const &)\n");
  return NULL; }
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;
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ExceptionFactory *)new mvIMPACT::acquire::ExceptionFactory(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::ComponentAccess const *)arg1)->changedCounter(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::ComponentAccess const *)arg1)->changedCounterAttr(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::HOBJ)((mvIMPACT::acquire::ComponentAccess const *)arg1)->hObj(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::ComponentAccess const *)arg1)->name(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::ComponentAccess const *)arg1)->displayName(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__ComponentAccess, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Component__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Component *)new mvIMPACT::acquire::Component(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Component *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { result = (mvIMPACT::acquire::Component *)new mvIMPACT::acquire::Component(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_Component",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_Component__SWIG_1(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_Component__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Component'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::Component(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::Component()\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Component const *)arg1)->firstSibling(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Component const *)arg1)->lastSibling(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (arg1)->nextSibling(); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Component const *)arg1)->firstChild(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Component const *)arg1)->parent(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Component const *)arg1)->docString(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TComponentFlag)((mvIMPACT::acquire::Component const *)arg1)->flags(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_flagsAsString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Component const *)arg1)->flagsAsString((std::string const &)*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Component const *)arg1)->flagsAsString(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_flagsAsString(PyObject *self, PyObject *args) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"Component_flagsAsString",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_Component_flagsAsString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_Component_flagsAsString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Component_flagsAsString'.\n"
  "  Possible C/C++ prototypes are:\n" "    flagsAsString(mvIMPACT::acquire::Component const *,std::string const &)\n"
  "    flagsAsString(mvIMPACT::acquire::Component const *)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::Component const *)arg1)->isDefault(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::Component const *)arg1)->isList(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::Component const *)arg1)->isMeth(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::Component const *)arg1)->isProp(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::Component const *)arg1)->isValid(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::Component const *)arg1)->isVisible(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::Component const *)arg1)->isWriteable(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Component *) &((mvIMPACT::acquire::Component const *)arg1)->restoreDefault(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Component, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_getType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Component *arg1 = (mvIMPACT::acquire::Component *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; mvIMPACT::acquire::TComponentType 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_getType" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TComponentType)((mvIMPACT::acquire::Component const *)arg1)->type(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_getType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ; mvIMPACT::acquire::TComponentType 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 '" "Component_getType" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TComponentType)mvIMPACT::acquire::Component::type(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_getType(PyObject *self, PyObject *args) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"Component_getType",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__Component, 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_1; return _wrap_Component_getType__SWIG_0(self, argc, argv);}  check_1:
  if (argc == 1) { return _wrap_Component_getType__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Component_getType'.\n"
  "  Possible C/C++ prototypes are:\n" "    type(mvIMPACT::acquire::Component const *)\n"
  "    mvIMPACT::acquire::Component::type(mvIMPACT::acquire::HOBJ)\n"); 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Component const *)arg1)->typeAsString(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TComponentVisibility)((mvIMPACT::acquire::Component const *)arg1)->visibility(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_visibilityAsString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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_visibilityAsString" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Component const *)arg1)->visibilityAsString(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_visibilityAsString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::TComponentVisibility 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 '" "Component_visibilityAsString" "', argument " "1"" of type '" "mvIMPACT::acquire::TComponentVisibility""'"); }
    arg1 = static_cast< mvIMPACT::acquire::TComponentVisibility >(val1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = mvIMPACT::acquire::Component::visibilityAsString(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_visibilityAsString(PyObject *self, PyObject *args) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"Component_visibilityAsString",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__Component, 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_1; return _wrap_Component_visibilityAsString__SWIG_0(self, argc, argv);} 
  check_1: if (argc == 1) { return _wrap_Component_visibilityAsString__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Component_visibilityAsString'.\n"
  "  Possible C/C++ prototypes are:\n" "    visibilityAsString(mvIMPACT::acquire::Component const *)\n"
  "    mvIMPACT::acquire::Component::visibilityAsString(mvIMPACT::acquire::TComponentVisibility)\n"); 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TComponentRepresentation)((mvIMPACT::acquire::Component const *)arg1)->representation(); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_representationAsString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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_representationAsString" "', argument " "1"" of type '" "mvIMPACT::acquire::Component const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Component * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Component const *)arg1)->representationAsString(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_representationAsString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::TComponentRepresentation 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 '" "Component_representationAsString" "', argument " "1"" of type '" "mvIMPACT::acquire::TComponentRepresentation""'"); }
    arg1 = static_cast< mvIMPACT::acquire::TComponentRepresentation >(val1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = mvIMPACT::acquire::Component::representationAsString(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Component_representationAsString(PyObject *self, PyObject *args) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"Component_representationAsString",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__Component, 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_1;
    return _wrap_Component_representationAsString__SWIG_0(self, argc, argv);}  check_1: if (argc == 1) {
    return _wrap_Component_representationAsString__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Component_representationAsString'.\n"
  "  Possible C/C++ prototypes are:\n" "    representationAsString(mvIMPACT::acquire::Component const *)\n"
  "    mvIMPACT::acquire::Component::representationAsString(mvIMPACT::acquire::TComponentRepresentation)\n"); 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::Component const *)arg1)->selectedFeatureCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::Component const *)arg1)->selectingFeatureCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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 > *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_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 > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Component_selectedFeatures" "', argument " "2"" of type '" "std::vector< mvIMPACT::acquire::Component > &""'"); }
   arg2 = reinterpret_cast< std::vector< mvIMPACT::acquire::Component > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::Component const *)arg1)->selectedFeatures(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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 > *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_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 > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Component_selectingFeatures" "', argument " "2"" of type '" "std::vector< mvIMPACT::acquire::Component > &""'"); }
   arg2 = reinterpret_cast< std::vector< mvIMPACT::acquire::Component > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::Component const *)arg1)->selectingFeatures(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Component const *)arg1)->selectedFeature(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Component const *)arg1)->selectingFeature(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; void *arg1 = (void *) 0 ; int res1 ; mvIMPACT::acquire::ComponentCallback *result = 0 ;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComponentCallback" "', argument " "1"" of type '" "void *""'");  }
   { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ComponentCallback *)new mvIMPACT::acquire::ComponentCallback(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentCallback *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ComponentCallback *)new mvIMPACT::acquire::ComponentCallback(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentCallback *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::ComponentCallback *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) 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 '" "new_ComponentCallback" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentCallback const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComponentCallback" "', argument " "1"" of type '" "mvIMPACT::acquire::ComponentCallback const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::ComponentCallback * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ComponentCallback *)new mvIMPACT::acquire::ComponentCallback((mvIMPACT::acquire::ComponentCallback const &)*arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ComponentCallback",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_ComponentCallback__SWIG_1(self, argc, argv);}  if (argc == 1) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mvIMPACT__acquire__ComponentCallback, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_2; return _wrap_new_ComponentCallback__SWIG_2(self, argc, argv);}  check_2: if (argc == 1) {
    return _wrap_new_ComponentCallback__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ComponentCallback'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::ComponentCallback(void *)\n"
  "    mvIMPACT::acquire::ComponentCallback()\n"
  "    mvIMPACT::acquire::ComponentCallback(mvIMPACT::acquire::ComponentCallback const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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; }  }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::ComponentCallback const *)arg1)->isComponentRegistered(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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; }  }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)(arg1)->registerComponent(arg2); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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; }  }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)(arg1)->unregisterComponent(arg2); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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] ;
  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 *""'");  }
   { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { (arg1)->execute(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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,(char*)"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), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentLocatorBase *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ComponentLocatorBase *)new mvIMPACT::acquire::ComponentLocatorBase(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ComponentLocatorBase *)new mvIMPACT::acquire::ComponentLocatorBase(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ComponentLocatorBase *)new mvIMPACT::acquire::ComponentLocatorBase(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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(PyObject *self, PyObject *args) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ComponentLocatorBase",0,2,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_ComponentLocatorBase__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_ComponentLocatorBase__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_ComponentLocatorBase__SWIG_2(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ComponentLocatorBase'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::ComponentLocatorBase()\n"
  "    mvIMPACT::acquire::ComponentLocatorBase(mvIMPACT::acquire::HLIST)\n"
  "    mvIMPACT::acquire::ComponentLocatorBase(mvIMPACT::acquire::HLIST,std::string const &)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_ComponentLocatorBase_bindComponent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::ComponentLocatorBase const *)arg1)->bindComponent(*arg2,(std::string const &)*arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::ComponentLocatorBase const *)arg1)->bindComponent(*arg2,(std::string const &)*arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::ComponentLocatorBase const *)arg1)->bindComponent(*arg2,(std::string const &)*arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"ComponentLocatorBase_bindComponent",0,5,argv))) SWIG_fail; --argc; if (argc == 3) {
    return _wrap_ComponentLocatorBase_bindComponent__SWIG_2(self, argc, argv);}  if (argc == 4) {
    return _wrap_ComponentLocatorBase_bindComponent__SWIG_1(self, argc, argv);}  if (argc == 5) {
    return _wrap_ComponentLocatorBase_bindComponent__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ComponentLocatorBase_bindComponent'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    bindComponent(mvIMPACT::acquire::ComponentLocatorBase const *,mvIMPACT::acquire::Component &,std::string const &,int,int)\n"
  "    bindComponent(mvIMPACT::acquire::ComponentLocatorBase const *,mvIMPACT::acquire::Component &,std::string const &,int)\n"
  "    bindComponent(mvIMPACT::acquire::ComponentLocatorBase const *,mvIMPACT::acquire::Component &,std::string const &)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_ComponentLocatorBase_bindSearchBase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::HLIST)(arg1)->bindSearchBase(arg2,(std::string const &)*arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::HLIST)(arg1)->bindSearchBase(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_ComponentLocatorBase_bindSearchBase(PyObject *self, PyObject *args) { int argc; PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"ComponentLocatorBase_bindSearchBase",0,3,argv))) SWIG_fail; --argc;
  if (argc == 2) { return _wrap_ComponentLocatorBase_bindSearchBase__SWIG_1(self, argc, argv);}  if (argc == 3) {
    return _wrap_ComponentLocatorBase_bindSearchBase__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ComponentLocatorBase_bindSearchBase'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    bindSearchBase(mvIMPACT::acquire::ComponentLocatorBase *,mvIMPACT::acquire::HLIST,std::string const &)\n"
  "    bindSearchBase(mvIMPACT::acquire::ComponentLocatorBase *,mvIMPACT::acquire::HLIST)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_ComponentLocatorBase_findComponent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::HOBJ)((mvIMPACT::acquire::ComponentLocatorBase const *)arg1)->findComponent((std::string const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::HOBJ)((mvIMPACT::acquire::ComponentLocatorBase const *)arg1)->findComponent((std::string const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::HOBJ)((mvIMPACT::acquire::ComponentLocatorBase const *)arg1)->findComponent((std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"ComponentLocatorBase_findComponent",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    return _wrap_ComponentLocatorBase_findComponent__SWIG_2(self, argc, argv);}  if (argc == 3) {
    return _wrap_ComponentLocatorBase_findComponent__SWIG_1(self, argc, argv);}  if (argc == 4) {
    return _wrap_ComponentLocatorBase_findComponent__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ComponentLocatorBase_findComponent'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    findComponent(mvIMPACT::acquire::ComponentLocatorBase const *,std::string const &,int,int)\n"
  "    findComponent(mvIMPACT::acquire::ComponentLocatorBase const *,std::string const &,int)\n"
  "    findComponent(mvIMPACT::acquire::ComponentLocatorBase const *,std::string const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::HLIST)((mvIMPACT::acquire::ComponentLocatorBase const *)arg1)->searchbase_id(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentLocator *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ComponentLocator *)new mvIMPACT::acquire::ComponentLocator(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ComponentLocator *)new mvIMPACT::acquire::ComponentLocator(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ComponentLocator *)new mvIMPACT::acquire::ComponentLocator(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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(PyObject *self, PyObject *args) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ComponentLocator",0,2,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_ComponentLocator__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_ComponentLocator__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_ComponentLocator__SWIG_2(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ComponentLocator'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::ComponentLocator()\n"
  "    mvIMPACT::acquire::ComponentLocator(mvIMPACT::acquire::HLIST)\n"
  "    mvIMPACT::acquire::ComponentLocator(mvIMPACT::acquire::HLIST,std::string const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ComponentList *)new mvIMPACT::acquire::ComponentList(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::ComponentList *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ComponentList *)new mvIMPACT::acquire::ComponentList(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ComponentList",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_ComponentList__SWIG_1(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_ComponentList__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ComponentList'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::ComponentList(mvIMPACT::acquire::HLIST)\n"
  "    mvIMPACT::acquire::ComponentList()\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::ComponentList const *)arg1)->size(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::ComponentList const *)arg1)->contentDescriptor(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Method *)new mvIMPACT::acquire::Method(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Method *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { result = (mvIMPACT::acquire::Method *)new mvIMPACT::acquire::Method(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_Method",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_Method__SWIG_1(self, argc, argv);}  if (argc == 1) { return _wrap_new_Method__SWIG_0(self, argc, argv);} 
  fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Method'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::Method(mvIMPACT::acquire::HOBJ)\n"
  "    mvIMPACT::acquire::Method()\n"); return NULL; }
SWIGINTERN PyObject *_wrap_Method_call__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::Method const *)arg1)->call((std::string const &)*arg2,(std::string const &)*arg3); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_1(PyObject *SWIGUNUSEDPARM(self), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::Method const *)arg1)->call((std::string const &)*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_2(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::Method const *)arg1)->call(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Method_call(PyObject *self, PyObject *args) { int argc; PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"Method_call",0,3,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_Method_call__SWIG_2(self, argc, argv);}  if (argc == 2) { return _wrap_Method_call__SWIG_1(self, argc, argv);} 
  if (argc == 3) { return _wrap_Method_call__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Method_call'.\n"
  "  Possible C/C++ prototypes are:\n" "    call(mvIMPACT::acquire::Method const *,std::string const &,std::string const &)\n"
  "    call(mvIMPACT::acquire::Method const *,std::string const &)\n" "    call(mvIMPACT::acquire::Method const *)\n");
  return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Method const *)arg1)->paramList(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Property *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { result = (mvIMPACT::acquire::Property *)new mvIMPACT::acquire::Property(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Property *)new mvIMPACT::acquire::Property(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_Property",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_Property__SWIG_0(self, argc, argv);}  if (argc == 1) { return _wrap_new_Property__SWIG_1(self, argc, argv);}
   fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Property'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::Property()\n"
  "    mvIMPACT::acquire::Property(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_Property_allowsValueCombinations(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_allowsValueCombinations" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::Property const *)arg1)->allowsValueCombinations(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::Property const *)arg1)->dictSize(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::Property const *)arg1)->hasDict(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Property_hasMaxValue(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_hasMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::Property const *)arg1)->hasMaxValue(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Property_hasMinValue(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_hasMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::Property const *)arg1)->hasMinValue(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Property_hasStepWidth(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_hasStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::Property const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Property * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::Property const *)arg1)->hasStepWidth(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Property_readS__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Property const *)arg1)->readS(arg2,(std::string const &)*arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Property const *)arg1)->readS(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Property const *)arg1)->readS(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Property_readS(PyObject *self, PyObject *args) { int argc; PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"Property_readS",0,3,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_Property_readS__SWIG_2(self, argc, argv);}  if (argc == 2) {
    return _wrap_Property_readS__SWIG_1(self, argc, argv);}  if (argc == 3) {
    return _wrap_Property_readS__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Property_readS'.\n"
  "  Possible C/C++ prototypes are:\n" "    readS(mvIMPACT::acquire::Property const *,int,std::string const &)\n"
  "    readS(mvIMPACT::acquire::Property const *,int)\n" "    readS(mvIMPACT::acquire::Property const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_Property_readSArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Property const *)arg1)->readSArray((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Property const *)arg1)->readSArray((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Property const *)arg1)->readSArray((std::string const &)*arg2,(std::string const &)*arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Property const *)arg1)->readSArray((std::string const &)*arg2,(std::string const &)*arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Property const *)arg1)->readSArray((std::string const &)*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Property const *)arg1)->readSArray(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Property_readSArray(PyObject *self, PyObject *args) { int argc; PyObject *argv[7];
  if (!(argc = SWIG_Python_UnpackTuple(args,"Property_readSArray",0,6,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_Property_readSArray__SWIG_5(self, argc, argv);}  if (argc == 2) {
    return _wrap_Property_readSArray__SWIG_4(self, argc, argv);}  if (argc == 3) {
    return _wrap_Property_readSArray__SWIG_3(self, argc, argv);}  if (argc == 4) {
    return _wrap_Property_readSArray__SWIG_2(self, argc, argv);}  if (argc == 5) {
    return _wrap_Property_readSArray__SWIG_1(self, argc, argv);}  if (argc == 6) {
    return _wrap_Property_readSArray__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Property_readSArray'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    readSArray(mvIMPACT::acquire::Property const *,std::string const &,std::string const &,int,int,int)\n"
  "    readSArray(mvIMPACT::acquire::Property const *,std::string const &,std::string const &,int,int)\n"
  "    readSArray(mvIMPACT::acquire::Property const *,std::string const &,std::string const &,int)\n"
  "    readSArray(mvIMPACT::acquire::Property const *,std::string const &,std::string const &)\n"
  "    readSArray(mvIMPACT::acquire::Property const *,std::string const &)\n"
  "    readSArray(mvIMPACT::acquire::Property const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_Property_removeValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Property *) &((mvIMPACT::acquire::Property const *)arg1)->removeValue(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Property *) &((mvIMPACT::acquire::Property const *)arg1)->removeValue(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"Property_removeValue",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_Property_removeValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_Property_removeValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Property_removeValue'.\n"
  "  Possible C/C++ prototypes are:\n" "    removeValue(mvIMPACT::acquire::Property const *,int)\n"
  "    removeValue(mvIMPACT::acquire::Property const *)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Property *) &((mvIMPACT::acquire::Property const *)arg1)->resizeValArray(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Property const *)arg1)->stringFormatString(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::Property const *)arg1)->valCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::Property const *)arg1)->maxValCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Property *) &((mvIMPACT::acquire::Property const *)arg1)->writeS((std::string const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Property *) &((mvIMPACT::acquire::Property const *)arg1)->writeS((std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ;
  std::vector< std::string > *arg2 = 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0  | 0); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Property_writeS" "', argument " "2"" of type '" "std::vector< std::string > const &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Property_writeS" "', argument " "2"" of type '" "std::vector< std::string > const &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Property *) &((mvIMPACT::acquire::Property const *)arg1)->writeS((std::vector< std::string > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Property_writeS__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Property *arg1 = (mvIMPACT::acquire::Property *) 0 ;
  std::vector< std::string > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0  | 0); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Property_writeS" "', argument " "2"" of type '" "std::vector< std::string > const &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Property_writeS" "', argument " "2"" of type '" "std::vector< std::string > const &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Property *) &((mvIMPACT::acquire::Property const *)arg1)->writeS((std::vector< std::string > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Property, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_Property_writeS(PyObject *self, PyObject *args) { int argc; PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"Property_writeS",0,3,argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__string_t, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_1; return _wrap_Property_writeS__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_Property_writeS__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__string_t, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_3; return _wrap_Property_writeS__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) {
    return _wrap_Property_writeS__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Property_writeS'.\n"
  "  Possible C/C++ prototypes are:\n" "    writeS(mvIMPACT::acquire::Property const *,std::string const &,int)\n"
  "    writeS(mvIMPACT::acquire::Property const *,std::string const &)\n"
  "    writeS(mvIMPACT::acquire::Property const *,std::vector< std::string > const &,int)\n"
  "    writeS(mvIMPACT::acquire::Property const *,std::vector< std::string > const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyF__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyF< double > *)new mvIMPACT::acquire::EnumPropertyF< double >(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyF< double > *)new mvIMPACT::acquire::EnumPropertyF< double >(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyF",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyF__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyF__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyF'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyF< double >()\n"
  "    mvIMPACT::acquire::EnumPropertyF< double >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *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); {
    std::vector<std::pair< std::string, double> >* pV; if( !PyList_Check(swig_obj[1]) ) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    pV = new std::vector<std::pair< std::string, double> > (0); arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyF< double > *) &((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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; }  }  }  { if( arg2 ) { delete( arg2 ); }  }
   return resultobj; fail: { if( arg2 ) { delete( arg2 ); }  }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->getTranslationDictString(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->getTranslationDictString(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_getTranslationDictString(PyObject *self, PyObject *args) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyF_getTranslationDictString",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyF_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyF_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyF_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n" "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyF< double > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyF< double > const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (double)((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->getTranslationDictValue(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (double)((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->getTranslationDictValue(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_getTranslationDictValue(PyObject *self, PyObject *args) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyF_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyF_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyF_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyF_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n" "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyF< double > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyF< double > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyF_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyF_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyF< double > *) &((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyF_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< 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> * const pV = new std::vector<double> (0); arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyF< double > *) &((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 ); { } 
  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (double)((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->read(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (double)((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->read(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (double)((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->getMaxValue(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (double)((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->getMinValue(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (double)((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->getStepWidth(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< 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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< 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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< 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> * const pV = new std::vector<double> (0); arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< 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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->read(*arg2,arg3,arg4,arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< 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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< 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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyF_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyF_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]);  } } 
    if (!_v) goto check_2; return _wrap_PropertyF_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyF_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyF_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyF_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyF_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyF_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyF_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyF_read'.\n"
  "  Possible C/C++ prototypes are:\n" "    read(mvIMPACT::acquire::EnumPropertyF< double > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyF< double > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyF< double > const *,std::vector< double > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyF< double > const *,std::vector< double > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyF< double > const *,std::vector< double > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyF< double > const *,std::vector< double > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyF< double > const *,std::vector< double > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyF< double > const *,std::vector< double > &,bool)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyF< double > *) &((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyF_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyF< double > *) &((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyF_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< 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 (!PySequence_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; }  const int size = PySequence_Length(swig_obj[1]);
    std::vector<double> * const pV = new std::vector<double> (size); for (int i = 0; i < size; i++) {
      PyObject * const o = PySequence_GetItem(swig_obj[1],i); std::vector<double>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_double,SWIG_POINTER_EXCEPTION) == -1) { SWIG_fail; } 
      (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyF< double > *) &((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->write((std::vector< double > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 ); { } 
  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< 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 (!PySequence_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; }  const int size = PySequence_Length(swig_obj[1]);
    std::vector<double> * const pV = new std::vector<double> (size); for (int i = 0; i < size; i++) {
      PyObject * const o = PySequence_GetItem(swig_obj[1],i); std::vector<double>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_double,SWIG_POINTER_EXCEPTION) == -1) { SWIG_fail; } 
      (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyF< double > *) &((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->write((std::vector< double > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 ); { } 
  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< 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 (!PySequence_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; }  const int size = PySequence_Length(swig_obj[1]);
    std::vector<double> * const pV = new std::vector<double> (size); for (int i = 0; i < size; i++) {
      PyObject * const o = PySequence_GetItem(swig_obj[1],i); std::vector<double>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_double,SWIG_POINTER_EXCEPTION) == -1) { SWIG_fail; } 
      (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyF< double > *) &((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->write((std::vector< double > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 ); { } 
  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyF< double > *arg1 = (mvIMPACT::acquire::EnumPropertyF< double > *) 0 ;
  std::vector< 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 (!PySequence_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; }  const int size = PySequence_Length(swig_obj[1]);
    std::vector<double> * const pV = new std::vector<double> (size); for (int i = 0; i < size; i++) {
      PyObject * const o = PySequence_GetItem(swig_obj[1],i); std::vector<double>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_double,SWIG_POINTER_EXCEPTION) == -1) { SWIG_fail; } 
      (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyF< double > *) &((mvIMPACT::acquire::EnumPropertyF< double > const *)arg1)->write((std::vector< double > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyFT_double_t, 0 |  0 ); { } 
  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyF_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyF_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1; return _wrap_PropertyF_write__SWIG_3(self, argc, argv);} 
  check_1: if (argc == 2) { return _wrap_PropertyF_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; return _wrap_PropertyF_write__SWIG_2(self, argc, argv);} 
  check_3: if (argc == 3) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyF_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyF_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyF_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyF_write'.\n"
  "  Possible C/C++ prototypes are:\n" "    write(mvIMPACT::acquire::EnumPropertyF< double > const *,double,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyF< double > const *,double)\n"
  "    write(mvIMPACT::acquire::EnumPropertyF< double > const *,std::vector< double > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyF< double > const *,std::vector< double > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyF< double > const *,std::vector< double > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyF< double > const *,std::vector< double > const &,bool)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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_PropertyIAcquisitionMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIAcquisitionMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIAcquisitionMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIAcquisitionMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIAcquisitionMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIAcquisitionMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIAcquisitionMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAcquisitionMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAcquisitionMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIAcquisitionMode_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIAcquisitionMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAcquisitionMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAcquisitionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAcquisitionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAcquisitionMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIAcquisitionMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIAcquisitionMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAcquisitionMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIAcquisitionMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIAcquisitionMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TAcquisitionMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAcquisitionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAcquisitionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAcquisitionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAcquisitionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAcquisitionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TAcquisitionMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAcquisitionMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIAcquisitionMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIAcquisitionMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIAcquisitionMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAcquisitionMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIAcquisitionMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIAcquisitionMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIAcquisitionMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIAcquisitionMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAcquisitionMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *,std::vector< mvIMPACT::acquire::TAcquisitionMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *,std::vector< mvIMPACT::acquire::TAcquisitionMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *,std::vector< mvIMPACT::acquire::TAcquisitionMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *,std::vector< mvIMPACT::acquire::TAcquisitionMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *,std::vector< mvIMPACT::acquire::TAcquisitionMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *,std::vector< mvIMPACT::acquire::TAcquisitionMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAcquisitionMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAcquisitionMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAcquisitionMode> * const pV = new std::vector<mvIMPACT::acquire::TAcquisitionMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAcquisitionMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAcquisitionMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAcquisitionMode> * const pV = new std::vector<mvIMPACT::acquire::TAcquisitionMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAcquisitionMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAcquisitionMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAcquisitionMode> * const pV = new std::vector<mvIMPACT::acquire::TAcquisitionMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAcquisitionMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAcquisitionMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAcquisitionMode> * const pV = new std::vector<mvIMPACT::acquire::TAcquisitionMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAcquisitionMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAcquisitionMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAcquisitionMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIAcquisitionMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIAcquisitionMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIAcquisitionMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAcquisitionMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIAcquisitionMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIAcquisitionMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAcquisitionMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *,mvIMPACT::acquire::TAcquisitionMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *,mvIMPACT::acquire::TAcquisitionMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *,std::vector< mvIMPACT::acquire::TAcquisitionMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *,std::vector< mvIMPACT::acquire::TAcquisitionMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *,std::vector< mvIMPACT::acquire::TAcquisitionMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode > const *,std::vector< mvIMPACT::acquire::TAcquisitionMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIAcquisitionStartStopBehaviour__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIAcquisitionStartStopBehaviour",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyIAcquisitionStartStopBehaviour__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIAcquisitionStartStopBehaviour__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIAcquisitionStartStopBehaviour'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIAcquisitionStartStopBehaviour_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIAcquisitionStartStopBehaviour_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > &""'"); }
  
  arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > * >(argp2);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAcquisitionStartStopBehaviour_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictString(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAcquisitionStartStopBehaviour_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) {
    return _wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAcquisitionStartStopBehaviour_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAcquisitionStartStopBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAcquisitionStartStopBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictValue(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAcquisitionStartStopBehaviour_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) {
    return _wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAcquisitionStartStopBehaviour_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIAcquisitionStartStopBehaviour_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIAcquisitionStartStopBehaviour_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAcquisitionStartStopBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAcquisitionStartStopBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAcquisitionStartStopBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAcquisitionStartStopBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAcquisitionStartStopBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->read(*arg2); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_read(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAcquisitionStartStopBehaviour_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_1(self, argc, argv);}  if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIAcquisitionStartStopBehaviour_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAcquisitionStartStopBehaviour_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *,std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *,std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *,std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *,std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *,std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *,std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAcquisitionStartStopBehaviour_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAcquisitionStartStopBehaviour_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour> * const pV = new std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAcquisitionStartStopBehaviour,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour> * const pV = new std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAcquisitionStartStopBehaviour,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour> * const pV = new std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAcquisitionStartStopBehaviour,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour> * const pV = new std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAcquisitionStartStopBehaviour>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAcquisitionStartStopBehaviour,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionStartStopBehaviour_write(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAcquisitionStartStopBehaviour_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIAcquisitionStartStopBehaviour_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIAcquisitionStartStopBehaviour_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIAcquisitionStartStopBehaviour_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0;
    { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAcquisitionStartStopBehaviour_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIAcquisitionStartStopBehaviour_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIAcquisitionStartStopBehaviour_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAcquisitionStartStopBehaviour_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *,mvIMPACT::acquire::TAcquisitionStartStopBehaviour,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *,mvIMPACT::acquire::TAcquisitionStartStopBehaviour)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *,std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *,std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *,std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const *,std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIAoiMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIAoiMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIAoiMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIAoiMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIAoiMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIAoiMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TAoiMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIAoiMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TAoiMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TAoiMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAoiMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->getTranslationDictString(); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAoiMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIAoiMode_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIAoiMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAoiMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3]; if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAoiMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIAoiMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIAoiMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAoiMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIAoiMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIAoiMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TAoiMode> (0); arg2 = pV; }  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TAoiMode> (0); arg2 = pV; }  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAoiMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIAoiMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2; return _wrap_PropertyIAoiMode_read__SWIG_4(self, argc, argv);} 
  check_2: if (argc == 2) { return _wrap_PropertyIAoiMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAoiMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIAoiMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIAoiMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIAoiMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIAoiMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAoiMode_read'.\n"
  "  Possible C/C++ prototypes are:\n" "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *,std::vector< mvIMPACT::acquire::TAoiMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *,std::vector< mvIMPACT::acquire::TAoiMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *,std::vector< mvIMPACT::acquire::TAoiMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *,std::vector< mvIMPACT::acquire::TAoiMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *,std::vector< mvIMPACT::acquire::TAoiMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *,std::vector< mvIMPACT::acquire::TAoiMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAoiMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAoiMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAoiMode> * const pV = new std::vector<mvIMPACT::acquire::TAoiMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAoiMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAoiMode,SWIG_POINTER_EXCEPTION) == -1) { SWIG_fail; }
       (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAoiMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAoiMode> * const pV = new std::vector<mvIMPACT::acquire::TAoiMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAoiMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAoiMode,SWIG_POINTER_EXCEPTION) == -1) { SWIG_fail; }
       (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAoiMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAoiMode> * const pV = new std::vector<mvIMPACT::acquire::TAoiMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAoiMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAoiMode,SWIG_POINTER_EXCEPTION) == -1) { SWIG_fail; }
       (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAoiMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAoiMode> * const pV = new std::vector<mvIMPACT::acquire::TAoiMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAoiMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAoiMode,SWIG_POINTER_EXCEPTION) == -1) { SWIG_fail; }
       (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAoiMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAoiMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAoiMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAoiMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0;
    { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIAoiMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIAoiMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; return _wrap_PropertyIAoiMode_write__SWIG_2(self, argc, argv);} 
  check_3: if (argc == 3) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAoiMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIAoiMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIAoiMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAoiMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *,mvIMPACT::acquire::TAoiMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *,mvIMPACT::acquire::TAoiMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *,std::vector< mvIMPACT::acquire::TAoiMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *,std::vector< mvIMPACT::acquire::TAoiMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *,std::vector< mvIMPACT::acquire::TAoiMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode > const *,std::vector< mvIMPACT::acquire::TAoiMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIBayerConversionMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIBayerConversionMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIBayerConversionMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIBayerConversionMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIBayerConversionMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIBayerConversionMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIBayerConversionMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBayerConversionMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBayerConversionMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIBayerConversionMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIBayerConversionMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBayerConversionMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBayerConversionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBayerConversionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBayerConversionMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIBayerConversionMode_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIBayerConversionMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBayerConversionMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIBayerConversionMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIBayerConversionMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TBayerConversionMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBayerConversionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBayerConversionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBayerConversionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBayerConversionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBayerConversionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TBayerConversionMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBayerConversionMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIBayerConversionMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIBayerConversionMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIBayerConversionMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBayerConversionMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIBayerConversionMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIBayerConversionMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIBayerConversionMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIBayerConversionMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBayerConversionMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *,std::vector< mvIMPACT::acquire::TBayerConversionMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *,std::vector< mvIMPACT::acquire::TBayerConversionMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *,std::vector< mvIMPACT::acquire::TBayerConversionMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *,std::vector< mvIMPACT::acquire::TBayerConversionMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *,std::vector< mvIMPACT::acquire::TBayerConversionMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *,std::vector< mvIMPACT::acquire::TBayerConversionMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBayerConversionMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBayerConversionMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBayerConversionMode> * const pV = new std::vector<mvIMPACT::acquire::TBayerConversionMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBayerConversionMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBayerConversionMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerConversionMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBayerConversionMode> * const pV = new std::vector<mvIMPACT::acquire::TBayerConversionMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBayerConversionMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBayerConversionMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerConversionMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBayerConversionMode> * const pV = new std::vector<mvIMPACT::acquire::TBayerConversionMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBayerConversionMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBayerConversionMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerConversionMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBayerConversionMode> * const pV = new std::vector<mvIMPACT::acquire::TBayerConversionMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBayerConversionMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBayerConversionMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerConversionMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerConversionMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBayerConversionMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIBayerConversionMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIBayerConversionMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIBayerConversionMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBayerConversionMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIBayerConversionMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIBayerConversionMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBayerConversionMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *,mvIMPACT::acquire::TBayerConversionMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *,mvIMPACT::acquire::TBayerConversionMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *,std::vector< mvIMPACT::acquire::TBayerConversionMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *,std::vector< mvIMPACT::acquire::TBayerConversionMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *,std::vector< mvIMPACT::acquire::TBayerConversionMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode > const *,std::vector< mvIMPACT::acquire::TBayerConversionMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIBayerMosaicParity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIBayerMosaicParity",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIBayerMosaicParity__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIBayerMosaicParity__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIBayerMosaicParity'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIBayerMosaicParity_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIBayerMosaicParity_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBayerMosaicParity_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBayerMosaicParity_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIBayerMosaicParity_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIBayerMosaicParity_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBayerMosaicParity_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBayerMosaicParity)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBayerMosaicParity)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBayerMosaicParity_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIBayerMosaicParity_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIBayerMosaicParity_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBayerMosaicParity_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIBayerMosaicParity_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIBayerMosaicParity_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TBayerMosaicParity> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBayerMosaicParity)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBayerMosaicParity)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBayerMosaicParity)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBayerMosaicParity)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBayerMosaicParity)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TBayerMosaicParity> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBayerMosaicParity_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIBayerMosaicParity_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIBayerMosaicParity_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIBayerMosaicParity_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBayerMosaicParity_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIBayerMosaicParity_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIBayerMosaicParity_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIBayerMosaicParity_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIBayerMosaicParity_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBayerMosaicParity_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *,std::vector< mvIMPACT::acquire::TBayerMosaicParity > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *,std::vector< mvIMPACT::acquire::TBayerMosaicParity > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *,std::vector< mvIMPACT::acquire::TBayerMosaicParity > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *,std::vector< mvIMPACT::acquire::TBayerMosaicParity > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *,std::vector< mvIMPACT::acquire::TBayerMosaicParity > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *,std::vector< mvIMPACT::acquire::TBayerMosaicParity > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBayerMosaicParity_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBayerMosaicParity_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBayerMosaicParity> * const pV = new std::vector<mvIMPACT::acquire::TBayerMosaicParity> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBayerMosaicParity>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBayerMosaicParity,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerMosaicParity > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBayerMosaicParity> * const pV = new std::vector<mvIMPACT::acquire::TBayerMosaicParity> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBayerMosaicParity>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBayerMosaicParity,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerMosaicParity > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBayerMosaicParity> * const pV = new std::vector<mvIMPACT::acquire::TBayerMosaicParity> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBayerMosaicParity>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBayerMosaicParity,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerMosaicParity > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBayerMosaicParity> * const pV = new std::vector<mvIMPACT::acquire::TBayerMosaicParity> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBayerMosaicParity>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBayerMosaicParity,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerMosaicParity > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerMosaicParity_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerMosaicParity_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBayerMosaicParity_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIBayerMosaicParity_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIBayerMosaicParity_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIBayerMosaicParity_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBayerMosaicParity_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIBayerMosaicParity_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIBayerMosaicParity_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBayerMosaicParity_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *,mvIMPACT::acquire::TBayerMosaicParity,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *,mvIMPACT::acquire::TBayerMosaicParity)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *,std::vector< mvIMPACT::acquire::TBayerMosaicParity > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *,std::vector< mvIMPACT::acquire::TBayerMosaicParity > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *,std::vector< mvIMPACT::acquire::TBayerMosaicParity > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity > const *,std::vector< mvIMPACT::acquire::TBayerMosaicParity > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIBayerWhiteBalanceResult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIBayerWhiteBalanceResult",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyIBayerWhiteBalanceResult__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIBayerWhiteBalanceResult__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIBayerWhiteBalanceResult'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIBayerWhiteBalanceResult_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIBayerWhiteBalanceResult_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBayerWhiteBalanceResult_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBayerWhiteBalanceResult_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBayerWhiteBalanceResult_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBayerWhiteBalanceResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBayerWhiteBalanceResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBayerWhiteBalanceResult_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBayerWhiteBalanceResult_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIBayerWhiteBalanceResult_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIBayerWhiteBalanceResult_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBayerWhiteBalanceResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBayerWhiteBalanceResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBayerWhiteBalanceResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBayerWhiteBalanceResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBayerWhiteBalanceResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->read(*arg2,arg3); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->read(*arg2,arg3); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBayerWhiteBalanceResult_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0;
    { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIBayerWhiteBalanceResult_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBayerWhiteBalanceResult_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *,std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *,std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *,std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *,std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *,std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *,std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBayerWhiteBalanceResult_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBayerWhiteBalanceResult_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult> * const pV = new std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBayerWhiteBalanceResult,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult> * const pV = new std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBayerWhiteBalanceResult,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult> * const pV = new std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBayerWhiteBalanceResult,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult> * const pV = new std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBayerWhiteBalanceResult>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBayerWhiteBalanceResult,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBayerWhiteBalanceResult_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBayerWhiteBalanceResult_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIBayerWhiteBalanceResult_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIBayerWhiteBalanceResult_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIBayerWhiteBalanceResult_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBayerWhiteBalanceResult_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIBayerWhiteBalanceResult_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIBayerWhiteBalanceResult_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBayerWhiteBalanceResult_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *,mvIMPACT::acquire::TBayerWhiteBalanceResult,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *,mvIMPACT::acquire::TBayerWhiteBalanceResult)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *,std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *,std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *,std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult > const *,std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIBoolean__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIBoolean",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIBoolean__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIBoolean__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIBoolean'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIBoolean_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TBoolean > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIBoolean_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TBoolean > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TBoolean > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBoolean_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->getTranslationDictString(); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBoolean_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIBoolean_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIBoolean_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBoolean_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBoolean)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBoolean)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3]; if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBoolean_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIBoolean_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIBoolean_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBoolean_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIBoolean_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIBoolean_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TBoolean> (0); arg2 = pV; }  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBoolean)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBoolean)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBoolean)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBoolean)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBoolean)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TBoolean> (0); arg2 = pV; }  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->read(*arg2,arg3,arg4,arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBoolean_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIBoolean_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2; return _wrap_PropertyIBoolean_read__SWIG_4(self, argc, argv);} 
  check_2: if (argc == 2) { return _wrap_PropertyIBoolean_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBoolean_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIBoolean_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIBoolean_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIBoolean_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIBoolean_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBoolean_read'.\n"
  "  Possible C/C++ prototypes are:\n" "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *,std::vector< mvIMPACT::acquire::TBoolean > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *,std::vector< mvIMPACT::acquire::TBoolean > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *,std::vector< mvIMPACT::acquire::TBoolean > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *,std::vector< mvIMPACT::acquire::TBoolean > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *,std::vector< mvIMPACT::acquire::TBoolean > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *,std::vector< mvIMPACT::acquire::TBoolean > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBoolean_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBoolean_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBoolean> * const pV = new std::vector<mvIMPACT::acquire::TBoolean> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBoolean>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBoolean,SWIG_POINTER_EXCEPTION) == -1) { SWIG_fail; }
       (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBoolean > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBoolean> * const pV = new std::vector<mvIMPACT::acquire::TBoolean> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBoolean>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBoolean,SWIG_POINTER_EXCEPTION) == -1) { SWIG_fail; }
       (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBoolean > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBoolean> * const pV = new std::vector<mvIMPACT::acquire::TBoolean> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBoolean>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBoolean,SWIG_POINTER_EXCEPTION) == -1) { SWIG_fail; }
       (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBoolean > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBoolean> * const pV = new std::vector<mvIMPACT::acquire::TBoolean> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBoolean>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBoolean,SWIG_POINTER_EXCEPTION) == -1) { SWIG_fail; }
       (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBoolean > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBoolean_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBoolean_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBoolean_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0;
    { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIBoolean_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIBoolean_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; return _wrap_PropertyIBoolean_write__SWIG_2(self, argc, argv);} 
  check_3: if (argc == 3) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBoolean_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIBoolean_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIBoolean_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBoolean_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *,mvIMPACT::acquire::TBoolean,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *,mvIMPACT::acquire::TBoolean)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *,std::vector< mvIMPACT::acquire::TBoolean > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *,std::vector< mvIMPACT::acquire::TBoolean > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *,std::vector< mvIMPACT::acquire::TBoolean > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean > const *,std::vector< mvIMPACT::acquire::TBoolean > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyICameraOutput__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyICameraOutput",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyICameraOutput__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyICameraOutput__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyICameraOutput'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraOutput_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraOutput > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraOutput_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraOutput > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraOutput > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraOutput_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraOutput_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraOutput_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyICameraOutput_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraOutput_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraOutput_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraOutput_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyICameraOutput_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraOutput_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraOutput_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraOutput_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraOutput> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraOutput> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->read(*arg2,arg3,arg4,arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraOutput_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyICameraOutput_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraOutput_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyICameraOutput_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraOutput_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraOutput_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyICameraOutput_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyICameraOutput_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyICameraOutput_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraOutput_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *,std::vector< mvIMPACT::acquire::TCameraOutput > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *,std::vector< mvIMPACT::acquire::TCameraOutput > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *,std::vector< mvIMPACT::acquire::TCameraOutput > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *,std::vector< mvIMPACT::acquire::TCameraOutput > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *,std::vector< mvIMPACT::acquire::TCameraOutput > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *,std::vector< mvIMPACT::acquire::TCameraOutput > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraOutput_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraOutput_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraOutput> * const pV = new std::vector<mvIMPACT::acquire::TCameraOutput> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraOutput>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraOutput,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraOutput > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraOutput> * const pV = new std::vector<mvIMPACT::acquire::TCameraOutput> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraOutput>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraOutput,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraOutput > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraOutput> * const pV = new std::vector<mvIMPACT::acquire::TCameraOutput> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraOutput>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraOutput,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraOutput > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraOutput> * const pV = new std::vector<mvIMPACT::acquire::TCameraOutput> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraOutput>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraOutput,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraOutput > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraOutput_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraOutput_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraOutput_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyICameraOutput_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraOutput_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraOutput_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraOutput_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyICameraOutput_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraOutput_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *,mvIMPACT::acquire::TCameraOutput,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *,mvIMPACT::acquire::TCameraOutput)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *,std::vector< mvIMPACT::acquire::TCameraOutput > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *,std::vector< mvIMPACT::acquire::TCameraOutput > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *,std::vector< mvIMPACT::acquire::TCameraOutput > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput > const *,std::vector< mvIMPACT::acquire::TCameraOutput > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIChannelSplitMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIChannelSplitMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIChannelSplitMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIChannelSplitMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIChannelSplitMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIChannelSplitMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIChannelSplitMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIChannelSplitMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIChannelSplitMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIChannelSplitMode_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIChannelSplitMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIChannelSplitMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TChannelSplitMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TChannelSplitMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIChannelSplitMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIChannelSplitMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIChannelSplitMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIChannelSplitMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIChannelSplitMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIChannelSplitMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TChannelSplitMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TChannelSplitMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TChannelSplitMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TChannelSplitMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TChannelSplitMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TChannelSplitMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TChannelSplitMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIChannelSplitMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIChannelSplitMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIChannelSplitMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIChannelSplitMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIChannelSplitMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIChannelSplitMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIChannelSplitMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIChannelSplitMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIChannelSplitMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIChannelSplitMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *,std::vector< mvIMPACT::acquire::TChannelSplitMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *,std::vector< mvIMPACT::acquire::TChannelSplitMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *,std::vector< mvIMPACT::acquire::TChannelSplitMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *,std::vector< mvIMPACT::acquire::TChannelSplitMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *,std::vector< mvIMPACT::acquire::TChannelSplitMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *,std::vector< mvIMPACT::acquire::TChannelSplitMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIChannelSplitMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIChannelSplitMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TChannelSplitMode> * const pV = new std::vector<mvIMPACT::acquire::TChannelSplitMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TChannelSplitMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TChannelSplitMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TChannelSplitMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TChannelSplitMode> * const pV = new std::vector<mvIMPACT::acquire::TChannelSplitMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TChannelSplitMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TChannelSplitMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TChannelSplitMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TChannelSplitMode> * const pV = new std::vector<mvIMPACT::acquire::TChannelSplitMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TChannelSplitMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TChannelSplitMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TChannelSplitMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TChannelSplitMode> * const pV = new std::vector<mvIMPACT::acquire::TChannelSplitMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TChannelSplitMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TChannelSplitMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TChannelSplitMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TChannelSplitMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIChannelSplitMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIChannelSplitMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIChannelSplitMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIChannelSplitMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIChannelSplitMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIChannelSplitMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIChannelSplitMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIChannelSplitMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIChannelSplitMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *,mvIMPACT::acquire::TChannelSplitMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *,mvIMPACT::acquire::TChannelSplitMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *,std::vector< mvIMPACT::acquire::TChannelSplitMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *,std::vector< mvIMPACT::acquire::TChannelSplitMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *,std::vector< mvIMPACT::acquire::TChannelSplitMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode > const *,std::vector< mvIMPACT::acquire::TChannelSplitMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIColorTwistInputCorrectionMatrixMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIColorTwistInputCorrectionMatrixMode",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyIColorTwistInputCorrectionMatrixMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIColorTwistInputCorrectionMatrixMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIColorTwistInputCorrectionMatrixMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > &""'"); }
  
  arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > * >(argp2);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictString(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) {
    return _wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictString__SWIG_0(self, argc, argv);}
   fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) {
    return _wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValue__SWIG_0(self, argc, argv);}
   fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->read(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_read(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIColorTwistInputCorrectionMatrixMode_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIColorTwistInputCorrectionMatrixMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIColorTwistInputCorrectionMatrixMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *,std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *,std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *,std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *,std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *,std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *,std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode> * const pV = new std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode> * const pV = new std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode> * const pV = new std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode> * const pV = new std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistInputCorrectionMatrixMode_write(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIColorTwistInputCorrectionMatrixMode_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; {
      { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIColorTwistInputCorrectionMatrixMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIColorTwistInputCorrectionMatrixMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *,std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *,std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *,std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const *,std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > const &,bool)\n");
  return NULL; }
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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIColorTwistOutputCorrectionMatrixMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIColorTwistOutputCorrectionMatrixMode",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyIColorTwistOutputCorrectionMatrixMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIColorTwistOutputCorrectionMatrixMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIColorTwistOutputCorrectionMatrixMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > &""'"); }
  
  arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > * >(argp2);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictString(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) {
    return _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) {
    return _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) {
    return _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValue__SWIG_0(self, argc, argv);}
   fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->read(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIColorTwistOutputCorrectionMatrixMode_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; {
      { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; {
      { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIColorTwistOutputCorrectionMatrixMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *,std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *,std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *,std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *,std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *,std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *,std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode> * const pV = new std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode> * const pV = new std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode> * const pV = new std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode> * const pV = new std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIColorTwistOutputCorrectionMatrixMode_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; {
      { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIColorTwistOutputCorrectionMatrixMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *,std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *,std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *,std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const *,std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > const &,bool)\n");
  return NULL; }
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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIColorProcessingMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIColorProcessingMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIColorProcessingMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIColorProcessingMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIColorProcessingMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIColorProcessingMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIColorProcessingMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIColorProcessingMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIColorProcessingMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIColorProcessingMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIColorProcessingMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIColorProcessingMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TColorProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TColorProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIColorProcessingMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIColorProcessingMode_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIColorProcessingMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIColorProcessingMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIColorProcessingMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIColorProcessingMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TColorProcessingMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TColorProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TColorProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TColorProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TColorProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TColorProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TColorProcessingMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIColorProcessingMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIColorProcessingMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIColorProcessingMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIColorProcessingMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIColorProcessingMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIColorProcessingMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIColorProcessingMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIColorProcessingMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIColorProcessingMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIColorProcessingMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *,std::vector< mvIMPACT::acquire::TColorProcessingMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *,std::vector< mvIMPACT::acquire::TColorProcessingMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *,std::vector< mvIMPACT::acquire::TColorProcessingMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *,std::vector< mvIMPACT::acquire::TColorProcessingMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *,std::vector< mvIMPACT::acquire::TColorProcessingMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *,std::vector< mvIMPACT::acquire::TColorProcessingMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIColorProcessingMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIColorProcessingMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TColorProcessingMode> * const pV = new std::vector<mvIMPACT::acquire::TColorProcessingMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TColorProcessingMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TColorProcessingMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorProcessingMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TColorProcessingMode> * const pV = new std::vector<mvIMPACT::acquire::TColorProcessingMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TColorProcessingMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TColorProcessingMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorProcessingMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TColorProcessingMode> * const pV = new std::vector<mvIMPACT::acquire::TColorProcessingMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TColorProcessingMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TColorProcessingMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorProcessingMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TColorProcessingMode> * const pV = new std::vector<mvIMPACT::acquire::TColorProcessingMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TColorProcessingMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TColorProcessingMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TColorProcessingMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIColorProcessingMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIColorProcessingMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIColorProcessingMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIColorProcessingMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIColorProcessingMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIColorProcessingMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIColorProcessingMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIColorProcessingMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIColorProcessingMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *,mvIMPACT::acquire::TColorProcessingMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *,mvIMPACT::acquire::TColorProcessingMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *,std::vector< mvIMPACT::acquire::TColorProcessingMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *,std::vector< mvIMPACT::acquire::TColorProcessingMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *,std::vector< mvIMPACT::acquire::TColorProcessingMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode > const *,std::vector< mvIMPACT::acquire::TColorProcessingMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIDarkCurrentFilterMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDarkCurrentFilterMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIDarkCurrentFilterMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDarkCurrentFilterMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDarkCurrentFilterMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDarkCurrentFilterMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDarkCurrentFilterMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDarkCurrentFilterMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDarkCurrentFilterMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDarkCurrentFilterMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDarkCurrentFilterMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDarkCurrentFilterMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDarkCurrentFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDarkCurrentFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDarkCurrentFilterMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDarkCurrentFilterMode_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDarkCurrentFilterMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDarkCurrentFilterMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDarkCurrentFilterMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDarkCurrentFilterMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDarkCurrentFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDarkCurrentFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDarkCurrentFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDarkCurrentFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDarkCurrentFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->read(*arg2,arg3,arg4); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->read(*arg2,arg3,arg4); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDarkCurrentFilterMode_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDarkCurrentFilterMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; {
      { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDarkCurrentFilterMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDarkCurrentFilterMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDarkCurrentFilterMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDarkCurrentFilterMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDarkCurrentFilterMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDarkCurrentFilterMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDarkCurrentFilterMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDarkCurrentFilterMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *,std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *,std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *,std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *,std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *,std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *,std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDarkCurrentFilterMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDarkCurrentFilterMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode> * const pV = new std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDarkCurrentFilterMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode> * const pV = new std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDarkCurrentFilterMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode> * const pV = new std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDarkCurrentFilterMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode> * const pV = new std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDarkCurrentFilterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDarkCurrentFilterMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDarkCurrentFilterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDarkCurrentFilterMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDarkCurrentFilterMode_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDarkCurrentFilterMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDarkCurrentFilterMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDarkCurrentFilterMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDarkCurrentFilterMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDarkCurrentFilterMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDarkCurrentFilterMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDarkCurrentFilterMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *,mvIMPACT::acquire::TDarkCurrentFilterMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *,mvIMPACT::acquire::TDarkCurrentFilterMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *,std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *,std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *,std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode > const *,std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIDefectivePixelsFilterMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDefectivePixelsFilterMode",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyIDefectivePixelsFilterMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDefectivePixelsFilterMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDefectivePixelsFilterMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDefectivePixelsFilterMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDefectivePixelsFilterMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDefectivePixelsFilterMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictString(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDefectivePixelsFilterMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDefectivePixelsFilterMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDefectivePixelsFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDefectivePixelsFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDefectivePixelsFilterMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDefectivePixelsFilterMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDefectivePixelsFilterMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDefectivePixelsFilterMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDefectivePixelsFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDefectivePixelsFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDefectivePixelsFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDefectivePixelsFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDefectivePixelsFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->read(*arg2,arg3); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->read(*arg2,arg3); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_read(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[6]; if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDefectivePixelsFilterMode_read",0,5,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDefectivePixelsFilterMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDefectivePixelsFilterMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *,std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *,std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *,std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *,std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *,std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *,std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDefectivePixelsFilterMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDefectivePixelsFilterMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode> * const pV = new std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDefectivePixelsFilterMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode> * const pV = new std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDefectivePixelsFilterMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode> * const pV = new std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDefectivePixelsFilterMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode> * const pV = new std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDefectivePixelsFilterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDefectivePixelsFilterMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDefectivePixelsFilterMode_write(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5]; if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDefectivePixelsFilterMode_write",0,4,argv))) SWIG_fail;
  --argc; if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDefectivePixelsFilterMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDefectivePixelsFilterMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDefectivePixelsFilterMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDefectivePixelsFilterMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDefectivePixelsFilterMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDefectivePixelsFilterMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDefectivePixelsFilterMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *,mvIMPACT::acquire::TDefectivePixelsFilterMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *,mvIMPACT::acquire::TDefectivePixelsFilterMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *,std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *,std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *,std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode > const *,std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIDeviceAccessMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDeviceAccessMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIDeviceAccessMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDeviceAccessMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDeviceAccessMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceAccessMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceAccessMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceAccessMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceAccessMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceAccessMode_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIDeviceAccessMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceAccessMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceAccessMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceAccessMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceAccessMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceAccessMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIDeviceAccessMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceAccessMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceAccessMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceAccessMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceAccessMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceAccessMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceAccessMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceAccessMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceAccessMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceAccessMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceAccessMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceAccessMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIDeviceAccessMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceAccessMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDeviceAccessMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceAccessMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceAccessMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDeviceAccessMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDeviceAccessMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDeviceAccessMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceAccessMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *,std::vector< mvIMPACT::acquire::TDeviceAccessMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *,std::vector< mvIMPACT::acquire::TDeviceAccessMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *,std::vector< mvIMPACT::acquire::TDeviceAccessMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *,std::vector< mvIMPACT::acquire::TDeviceAccessMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *,std::vector< mvIMPACT::acquire::TDeviceAccessMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *,std::vector< mvIMPACT::acquire::TDeviceAccessMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceAccessMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceAccessMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceAccessMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceAccessMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceAccessMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceAccessMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceAccessMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceAccessMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceAccessMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceAccessMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceAccessMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceAccessMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceAccessMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceAccessMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceAccessMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceAccessMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceAccessMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceAccessMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceAccessMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceAccessMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceAccessMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceAccessMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAccessMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAccessMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceAccessMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceAccessMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDeviceAccessMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceAccessMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceAccessMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceAccessMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDeviceAccessMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceAccessMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *,mvIMPACT::acquire::TDeviceAccessMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *,mvIMPACT::acquire::TDeviceAccessMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *,std::vector< mvIMPACT::acquire::TDeviceAccessMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *,std::vector< mvIMPACT::acquire::TDeviceAccessMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *,std::vector< mvIMPACT::acquire::TDeviceAccessMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode > const *,std::vector< mvIMPACT::acquire::TDeviceAccessMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIDeviceCapability__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDeviceCapability",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIDeviceCapability__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDeviceCapability__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDeviceCapability'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceCapability_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceCapability_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceCapability_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceCapability_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceCapability_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIDeviceCapability_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceCapability_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceCapability)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceCapability)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceCapability_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceCapability_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIDeviceCapability_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceCapability_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceCapability_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceCapability_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceCapability> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceCapability)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceCapability)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceCapability)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceCapability)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceCapability)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceCapability> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->read(*arg2,arg3,arg4,arg5); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceCapability_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIDeviceCapability_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceCapability_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDeviceCapability_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceCapability_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceCapability_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDeviceCapability_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDeviceCapability_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDeviceCapability_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceCapability_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *,std::vector< mvIMPACT::acquire::TDeviceCapability > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *,std::vector< mvIMPACT::acquire::TDeviceCapability > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *,std::vector< mvIMPACT::acquire::TDeviceCapability > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *,std::vector< mvIMPACT::acquire::TDeviceCapability > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *,std::vector< mvIMPACT::acquire::TDeviceCapability > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *,std::vector< mvIMPACT::acquire::TDeviceCapability > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceCapability_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceCapability_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceCapability> * const pV = new std::vector<mvIMPACT::acquire::TDeviceCapability> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceCapability>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceCapability,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceCapability > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceCapability> * const pV = new std::vector<mvIMPACT::acquire::TDeviceCapability> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceCapability>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceCapability,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceCapability > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceCapability> * const pV = new std::vector<mvIMPACT::acquire::TDeviceCapability> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceCapability>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceCapability,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceCapability > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceCapability> * const pV = new std::vector<mvIMPACT::acquire::TDeviceCapability> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceCapability>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceCapability,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceCapability > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceCapability_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceCapability_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceCapability_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDeviceCapability_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceCapability_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceCapability_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceCapability_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDeviceCapability_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceCapability_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *,mvIMPACT::acquire::TDeviceCapability,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *,mvIMPACT::acquire::TDeviceCapability)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *,std::vector< mvIMPACT::acquire::TDeviceCapability > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *,std::vector< mvIMPACT::acquire::TDeviceCapability > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *,std::vector< mvIMPACT::acquire::TDeviceCapability > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability > const *,std::vector< mvIMPACT::acquire::TDeviceCapability > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIDeviceClass__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDeviceClass",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIDeviceClass__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDeviceClass__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDeviceClass'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceClass_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceClass > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceClass_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceClass > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceClass > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceClass_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceClass_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceClass_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIDeviceClass_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceClass_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceClass)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceClass)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceClass_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceClass_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIDeviceClass_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceClass_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceClass_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceClass_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceClass> (0); arg2 = pV; }
   { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceClass)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceClass)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceClass)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceClass)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceClass)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceClass> (0); arg2 = pV; }
   { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->read(*arg2,arg3,arg4,arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceClass_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIDeviceClass_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceClass_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDeviceClass_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceClass_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceClass_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDeviceClass_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDeviceClass_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDeviceClass_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceClass_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *,std::vector< mvIMPACT::acquire::TDeviceClass > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *,std::vector< mvIMPACT::acquire::TDeviceClass > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *,std::vector< mvIMPACT::acquire::TDeviceClass > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *,std::vector< mvIMPACT::acquire::TDeviceClass > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *,std::vector< mvIMPACT::acquire::TDeviceClass > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *,std::vector< mvIMPACT::acquire::TDeviceClass > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceClass_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceClass_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceClass> * const pV = new std::vector<mvIMPACT::acquire::TDeviceClass> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceClass>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceClass,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceClass > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceClass> * const pV = new std::vector<mvIMPACT::acquire::TDeviceClass> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceClass>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceClass,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceClass > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceClass> * const pV = new std::vector<mvIMPACT::acquire::TDeviceClass> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceClass>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceClass,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceClass > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceClass> * const pV = new std::vector<mvIMPACT::acquire::TDeviceClass> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceClass>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceClass,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceClass > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceClass_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceClass_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceClass_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceClass_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDeviceClass_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceClass_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceClass_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceClass_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDeviceClass_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceClass_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *,mvIMPACT::acquire::TDeviceClass,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *,mvIMPACT::acquire::TDeviceClass)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *,std::vector< mvIMPACT::acquire::TDeviceClass > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *,std::vector< mvIMPACT::acquire::TDeviceClass > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *,std::vector< mvIMPACT::acquire::TDeviceClass > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass > const *,std::vector< mvIMPACT::acquire::TDeviceClass > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIDeviceInterfaceLayout__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDeviceInterfaceLayout",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIDeviceInterfaceLayout__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDeviceInterfaceLayout__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDeviceInterfaceLayout'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceInterfaceLayout_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceInterfaceLayout_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceInterfaceLayout_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceInterfaceLayout_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDeviceInterfaceLayout_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDeviceInterfaceLayout_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceInterfaceLayout_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceInterfaceLayout)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceInterfaceLayout)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceInterfaceLayout_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDeviceInterfaceLayout_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDeviceInterfaceLayout_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceInterfaceLayout_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceInterfaceLayout_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceInterfaceLayout_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceInterfaceLayout)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceInterfaceLayout)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceInterfaceLayout)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceInterfaceLayout)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceInterfaceLayout)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->read(*arg2,arg3,arg4); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->read(*arg2,arg3,arg4); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceInterfaceLayout_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceInterfaceLayout_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; {
      { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceInterfaceLayout_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDeviceInterfaceLayout_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceInterfaceLayout_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceInterfaceLayout_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDeviceInterfaceLayout_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDeviceInterfaceLayout_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDeviceInterfaceLayout_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceInterfaceLayout_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *,std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *,std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *,std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *,std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *,std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *,std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceInterfaceLayout_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceInterfaceLayout_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout> * const pV = new std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceInterfaceLayout,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout> * const pV = new std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceInterfaceLayout,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout> * const pV = new std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceInterfaceLayout,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout> * const pV = new std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceInterfaceLayout>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceInterfaceLayout,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceInterfaceLayout_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceInterfaceLayout_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceInterfaceLayout_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDeviceInterfaceLayout_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceInterfaceLayout_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceInterfaceLayout_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceInterfaceLayout_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDeviceInterfaceLayout_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceInterfaceLayout_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *,mvIMPACT::acquire::TDeviceInterfaceLayout,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *,mvIMPACT::acquire::TDeviceInterfaceLayout)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *,std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *,std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *,std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout > const *,std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIDeviceLoadSettings__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDeviceLoadSettings",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIDeviceLoadSettings__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDeviceLoadSettings__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDeviceLoadSettings'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceLoadSettings_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceLoadSettings_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceLoadSettings_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceLoadSettings_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDeviceLoadSettings_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDeviceLoadSettings_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceLoadSettings_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceLoadSettings)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceLoadSettings)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceLoadSettings_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceLoadSettings_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDeviceLoadSettings_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceLoadSettings_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceLoadSettings_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceLoadSettings_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceLoadSettings> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceLoadSettings)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceLoadSettings)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceLoadSettings)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceLoadSettings)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceLoadSettings)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->read(*arg2,arg3,arg4); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceLoadSettings> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->read(*arg2,arg3,arg4); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceLoadSettings_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIDeviceLoadSettings_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceLoadSettings_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDeviceLoadSettings_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceLoadSettings_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceLoadSettings_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDeviceLoadSettings_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDeviceLoadSettings_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDeviceLoadSettings_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceLoadSettings_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *,std::vector< mvIMPACT::acquire::TDeviceLoadSettings > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *,std::vector< mvIMPACT::acquire::TDeviceLoadSettings > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *,std::vector< mvIMPACT::acquire::TDeviceLoadSettings > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *,std::vector< mvIMPACT::acquire::TDeviceLoadSettings > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *,std::vector< mvIMPACT::acquire::TDeviceLoadSettings > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *,std::vector< mvIMPACT::acquire::TDeviceLoadSettings > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceLoadSettings_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceLoadSettings_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceLoadSettings> * const pV = new std::vector<mvIMPACT::acquire::TDeviceLoadSettings> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceLoadSettings>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceLoadSettings,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceLoadSettings > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceLoadSettings> * const pV = new std::vector<mvIMPACT::acquire::TDeviceLoadSettings> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceLoadSettings>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceLoadSettings,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceLoadSettings > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceLoadSettings> * const pV = new std::vector<mvIMPACT::acquire::TDeviceLoadSettings> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceLoadSettings>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceLoadSettings,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceLoadSettings > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceLoadSettings> * const pV = new std::vector<mvIMPACT::acquire::TDeviceLoadSettings> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceLoadSettings>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceLoadSettings,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceLoadSettings > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceLoadSettings_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceLoadSettings_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceLoadSettings_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceLoadSettings_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDeviceLoadSettings_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceLoadSettings_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceLoadSettings_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceLoadSettings_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDeviceLoadSettings_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceLoadSettings_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *,mvIMPACT::acquire::TDeviceLoadSettings,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *,mvIMPACT::acquire::TDeviceLoadSettings)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *,std::vector< mvIMPACT::acquire::TDeviceLoadSettings > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *,std::vector< mvIMPACT::acquire::TDeviceLoadSettings > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *,std::vector< mvIMPACT::acquire::TDeviceLoadSettings > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings > const *,std::vector< mvIMPACT::acquire::TDeviceLoadSettings > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIDeviceState__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDeviceState",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIDeviceState__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDeviceState__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDeviceState'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceState_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceState > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceState_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceState > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceState > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceState_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceState_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceState_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIDeviceState_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceState_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceState_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceState_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIDeviceState_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceState_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceState_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceState_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceState> (0); arg2 = pV; }
   { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceState> (0); arg2 = pV; }
   { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->read(*arg2,arg3,arg4,arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceState_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIDeviceState_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceState_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDeviceState_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceState_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceState_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDeviceState_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDeviceState_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDeviceState_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceState_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *,std::vector< mvIMPACT::acquire::TDeviceState > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *,std::vector< mvIMPACT::acquire::TDeviceState > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *,std::vector< mvIMPACT::acquire::TDeviceState > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *,std::vector< mvIMPACT::acquire::TDeviceState > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *,std::vector< mvIMPACT::acquire::TDeviceState > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *,std::vector< mvIMPACT::acquire::TDeviceState > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceState_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceState_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceState> * const pV = new std::vector<mvIMPACT::acquire::TDeviceState> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceState>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceState,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceState > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceState> * const pV = new std::vector<mvIMPACT::acquire::TDeviceState> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceState>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceState,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceState > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceState> * const pV = new std::vector<mvIMPACT::acquire::TDeviceState> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceState>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceState,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceState > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceState> * const pV = new std::vector<mvIMPACT::acquire::TDeviceState> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceState>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceState,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceState > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceState_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceState_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceState_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDeviceState_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceState_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceState_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceState_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDeviceState_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceState_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *,mvIMPACT::acquire::TDeviceState,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *,mvIMPACT::acquire::TDeviceState)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *,std::vector< mvIMPACT::acquire::TDeviceState > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *,std::vector< mvIMPACT::acquire::TDeviceState > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *,std::vector< mvIMPACT::acquire::TDeviceState > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState > const *,std::vector< mvIMPACT::acquire::TDeviceState > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIFlatFieldFilterCorrectionMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIFlatFieldFilterCorrectionMode",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyIFlatFieldFilterCorrectionMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIFlatFieldFilterCorrectionMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIFlatFieldFilterCorrectionMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIFlatFieldFilterCorrectionMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIFlatFieldFilterCorrectionMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > &""'"); }
  
  arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > * >(argp2);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictString(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIFlatFieldFilterCorrectionMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) {
    return _wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIFlatFieldFilterCorrectionMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TFlatFieldFilterCorrectionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TFlatFieldFilterCorrectionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) {
    return _wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIFlatFieldFilterCorrectionMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIFlatFieldFilterCorrectionMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TFlatFieldFilterCorrectionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TFlatFieldFilterCorrectionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TFlatFieldFilterCorrectionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TFlatFieldFilterCorrectionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TFlatFieldFilterCorrectionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->read(*arg2); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_read(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIFlatFieldFilterCorrectionMode_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIFlatFieldFilterCorrectionMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIFlatFieldFilterCorrectionMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *,std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *,std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *,std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *,std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *,std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *,std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode> * const pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode> * const pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode> * const pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode> * const pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TFlatFieldFilterCorrectionMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterCorrectionMode_write(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIFlatFieldFilterCorrectionMode_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0;
    { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIFlatFieldFilterCorrectionMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIFlatFieldFilterCorrectionMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *,std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *,std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *,std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const *,std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIFlatFieldFilterMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIFlatFieldFilterMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIFlatFieldFilterMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIFlatFieldFilterMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIFlatFieldFilterMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIFlatFieldFilterMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIFlatFieldFilterMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIFlatFieldFilterMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIFlatFieldFilterMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIFlatFieldFilterMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIFlatFieldFilterMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIFlatFieldFilterMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TFlatFieldFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TFlatFieldFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIFlatFieldFilterMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIFlatFieldFilterMode_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIFlatFieldFilterMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIFlatFieldFilterMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIFlatFieldFilterMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIFlatFieldFilterMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TFlatFieldFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TFlatFieldFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TFlatFieldFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TFlatFieldFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TFlatFieldFilterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIFlatFieldFilterMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIFlatFieldFilterMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIFlatFieldFilterMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIFlatFieldFilterMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIFlatFieldFilterMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIFlatFieldFilterMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIFlatFieldFilterMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIFlatFieldFilterMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIFlatFieldFilterMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIFlatFieldFilterMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *,std::vector< mvIMPACT::acquire::TFlatFieldFilterMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *,std::vector< mvIMPACT::acquire::TFlatFieldFilterMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *,std::vector< mvIMPACT::acquire::TFlatFieldFilterMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *,std::vector< mvIMPACT::acquire::TFlatFieldFilterMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *,std::vector< mvIMPACT::acquire::TFlatFieldFilterMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *,std::vector< mvIMPACT::acquire::TFlatFieldFilterMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIFlatFieldFilterMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIFlatFieldFilterMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TFlatFieldFilterMode> * const pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TFlatFieldFilterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TFlatFieldFilterMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFlatFieldFilterMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TFlatFieldFilterMode> * const pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TFlatFieldFilterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TFlatFieldFilterMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFlatFieldFilterMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TFlatFieldFilterMode> * const pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TFlatFieldFilterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TFlatFieldFilterMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFlatFieldFilterMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TFlatFieldFilterMode> * const pV = new std::vector<mvIMPACT::acquire::TFlatFieldFilterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TFlatFieldFilterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TFlatFieldFilterMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFlatFieldFilterMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFlatFieldFilterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFlatFieldFilterMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIFlatFieldFilterMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIFlatFieldFilterMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIFlatFieldFilterMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIFlatFieldFilterMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIFlatFieldFilterMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIFlatFieldFilterMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIFlatFieldFilterMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIFlatFieldFilterMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *,mvIMPACT::acquire::TFlatFieldFilterMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *,mvIMPACT::acquire::TFlatFieldFilterMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *,std::vector< mvIMPACT::acquire::TFlatFieldFilterMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *,std::vector< mvIMPACT::acquire::TFlatFieldFilterMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *,std::vector< mvIMPACT::acquire::TFlatFieldFilterMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode > const *,std::vector< mvIMPACT::acquire::TFlatFieldFilterMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIHWUpdateResult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIHWUpdateResult",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIHWUpdateResult__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIHWUpdateResult__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIHWUpdateResult'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIHWUpdateResult_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIHWUpdateResult_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIHWUpdateResult_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIHWUpdateResult_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIHWUpdateResult_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIHWUpdateResult_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIHWUpdateResult_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::THWUpdateResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::THWUpdateResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIHWUpdateResult_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIHWUpdateResult_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIHWUpdateResult_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIHWUpdateResult_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIHWUpdateResult_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIHWUpdateResult_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::THWUpdateResult> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::THWUpdateResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::THWUpdateResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::THWUpdateResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::THWUpdateResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::THWUpdateResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::THWUpdateResult> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->read(*arg2,arg3,arg4,arg5); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIHWUpdateResult_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIHWUpdateResult_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIHWUpdateResult_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIHWUpdateResult_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIHWUpdateResult_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIHWUpdateResult_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIHWUpdateResult_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIHWUpdateResult_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIHWUpdateResult_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIHWUpdateResult_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *,std::vector< mvIMPACT::acquire::THWUpdateResult > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *,std::vector< mvIMPACT::acquire::THWUpdateResult > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *,std::vector< mvIMPACT::acquire::THWUpdateResult > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *,std::vector< mvIMPACT::acquire::THWUpdateResult > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *,std::vector< mvIMPACT::acquire::THWUpdateResult > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *,std::vector< mvIMPACT::acquire::THWUpdateResult > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIHWUpdateResult_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIHWUpdateResult_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::THWUpdateResult> * const pV = new std::vector<mvIMPACT::acquire::THWUpdateResult> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::THWUpdateResult>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__THWUpdateResult,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::THWUpdateResult > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::THWUpdateResult> * const pV = new std::vector<mvIMPACT::acquire::THWUpdateResult> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::THWUpdateResult>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__THWUpdateResult,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::THWUpdateResult > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::THWUpdateResult> * const pV = new std::vector<mvIMPACT::acquire::THWUpdateResult> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::THWUpdateResult>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__THWUpdateResult,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::THWUpdateResult > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::THWUpdateResult> * const pV = new std::vector<mvIMPACT::acquire::THWUpdateResult> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::THWUpdateResult>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__THWUpdateResult,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::THWUpdateResult > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__THWUpdateResult_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIHWUpdateResult_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIHWUpdateResult_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIHWUpdateResult_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIHWUpdateResult_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIHWUpdateResult_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIHWUpdateResult_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIHWUpdateResult_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIHWUpdateResult_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIHWUpdateResult_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *,mvIMPACT::acquire::THWUpdateResult,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *,mvIMPACT::acquire::THWUpdateResult)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *,std::vector< mvIMPACT::acquire::THWUpdateResult > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *,std::vector< mvIMPACT::acquire::THWUpdateResult > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *,std::vector< mvIMPACT::acquire::THWUpdateResult > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult > const *,std::vector< mvIMPACT::acquire::THWUpdateResult > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIImageBufferPixelFormat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIImageBufferPixelFormat",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyIImageBufferPixelFormat__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIImageBufferPixelFormat__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIImageBufferPixelFormat'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIImageBufferPixelFormat_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIImageBufferPixelFormat_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIImageBufferPixelFormat_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageBufferPixelFormat_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIImageBufferPixelFormat_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIImageBufferPixelFormat_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageBufferPixelFormat_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageBufferPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageBufferPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageBufferPixelFormat_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIImageBufferPixelFormat_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIImageBufferPixelFormat_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageBufferPixelFormat_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIImageBufferPixelFormat_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIImageBufferPixelFormat_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TImageBufferPixelFormat> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageBufferPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageBufferPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageBufferPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageBufferPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageBufferPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TImageBufferPixelFormat> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageBufferPixelFormat_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIImageBufferPixelFormat_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; {
      { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIImageBufferPixelFormat_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIImageBufferPixelFormat_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageBufferPixelFormat_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIImageBufferPixelFormat_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIImageBufferPixelFormat_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIImageBufferPixelFormat_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIImageBufferPixelFormat_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageBufferPixelFormat_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *,std::vector< mvIMPACT::acquire::TImageBufferPixelFormat > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *,std::vector< mvIMPACT::acquire::TImageBufferPixelFormat > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *,std::vector< mvIMPACT::acquire::TImageBufferPixelFormat > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *,std::vector< mvIMPACT::acquire::TImageBufferPixelFormat > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *,std::vector< mvIMPACT::acquire::TImageBufferPixelFormat > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *,std::vector< mvIMPACT::acquire::TImageBufferPixelFormat > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIImageBufferPixelFormat_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIImageBufferPixelFormat_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageBufferPixelFormat> * const pV = new std::vector<mvIMPACT::acquire::TImageBufferPixelFormat> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageBufferPixelFormat>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageBufferPixelFormat,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageBufferPixelFormat > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageBufferPixelFormat> * const pV = new std::vector<mvIMPACT::acquire::TImageBufferPixelFormat> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageBufferPixelFormat>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageBufferPixelFormat,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageBufferPixelFormat > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageBufferPixelFormat> * const pV = new std::vector<mvIMPACT::acquire::TImageBufferPixelFormat> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageBufferPixelFormat>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageBufferPixelFormat,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageBufferPixelFormat > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageBufferPixelFormat> * const pV = new std::vector<mvIMPACT::acquire::TImageBufferPixelFormat> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageBufferPixelFormat>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageBufferPixelFormat,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageBufferPixelFormat > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferPixelFormat_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageBufferPixelFormat_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIImageBufferPixelFormat_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIImageBufferPixelFormat_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIImageBufferPixelFormat_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageBufferPixelFormat_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIImageBufferPixelFormat_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIImageBufferPixelFormat_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageBufferPixelFormat_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *,mvIMPACT::acquire::TImageBufferPixelFormat,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *,mvIMPACT::acquire::TImageBufferPixelFormat)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *,std::vector< mvIMPACT::acquire::TImageBufferPixelFormat > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *,std::vector< mvIMPACT::acquire::TImageBufferPixelFormat > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *,std::vector< mvIMPACT::acquire::TImageBufferPixelFormat > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat > const *,std::vector< mvIMPACT::acquire::TImageBufferPixelFormat > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyI64BufferPartDataType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBufferPartDataType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyI64BufferPartDataType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBufferPartDataType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyI64BufferPartDataType(PyObject *self, PyObject *args) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyI64BufferPartDataType",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyI64BufferPartDataType__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyI64BufferPartDataType__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyI64BufferPartDataType'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< 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__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyI64BufferPartDataType_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyI64BufferPartDataType_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< 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__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< 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__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyI64BufferPartDataType_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyI64BufferPartDataType_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyI64BufferPartDataType_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyI64BufferPartDataType_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< 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__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBufferPartDataType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< 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__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBufferPartDataType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyI64BufferPartDataType_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyI64BufferPartDataType_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyI64BufferPartDataType_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyI64BufferPartDataType_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< std::string > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ;
  PyObject *swig_obj[2] ; mvIMPACT::acquire::EnumPropertyI< 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__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyI64BufferPartDataType_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyI64BufferPartDataType_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< mvIMPACT::acquire::TBufferPartDataType > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< 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__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBufferPartDataType> * const pV = new std::vector<mvIMPACT::acquire::TBufferPartDataType> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< 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__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBufferPartDataType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< 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__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBufferPartDataType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< 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__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBufferPartDataType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< 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__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBufferPartDataType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< 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__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBufferPartDataType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< 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__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBufferPartDataType> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->read(*arg2,arg3,arg4); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< 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__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBufferPartDataType> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< 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__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBufferPartDataType> * const pV = new std::vector<mvIMPACT::acquire::TBufferPartDataType> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< 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__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBufferPartDataType> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< 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__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBufferPartDataType> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->read(*arg2,arg3,arg4); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< 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__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TBufferPartDataType> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyI64BufferPartDataType_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyI64BufferPartDataType_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyI64BufferPartDataType_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyI64BufferPartDataType_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyI64BufferPartDataType_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyI64BufferPartDataType_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyI64BufferPartDataType_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyI64BufferPartDataType_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyI64BufferPartDataType_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyI64BufferPartDataType_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *,std::vector< mvIMPACT::acquire::TBufferPartDataType > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *,std::vector< mvIMPACT::acquire::TBufferPartDataType > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *,std::vector< mvIMPACT::acquire::TBufferPartDataType > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *,std::vector< mvIMPACT::acquire::TBufferPartDataType > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *,std::vector< mvIMPACT::acquire::TBufferPartDataType > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *,std::vector< mvIMPACT::acquire::TBufferPartDataType > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< 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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  mvIMPACT::acquire::TBufferPartDataType arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< mvIMPACT::acquire::TBufferPartDataType > *arg2 = 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBufferPartDataType> * const pV = new std::vector<mvIMPACT::acquire::TBufferPartDataType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBufferPartDataType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBufferPartDataType,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBufferPartDataType > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< mvIMPACT::acquire::TBufferPartDataType > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBufferPartDataType> * const pV = new std::vector<mvIMPACT::acquire::TBufferPartDataType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBufferPartDataType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBufferPartDataType,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBufferPartDataType > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< 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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBufferPartDataType> * const pV = new std::vector<mvIMPACT::acquire::TBufferPartDataType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBufferPartDataType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBufferPartDataType,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBufferPartDataType > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *) 0 ;
  std::vector< mvIMPACT::acquire::TBufferPartDataType > *arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    if (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBufferPartDataType> * const pV = new std::vector<mvIMPACT::acquire::TBufferPartDataType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBufferPartDataType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBufferPartDataType,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBufferPartDataType > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBufferPartDataType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64BufferPartDataType_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyI64BufferPartDataType_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyI64BufferPartDataType_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyI64BufferPartDataType_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyI64BufferPartDataType_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyI64BufferPartDataType_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyI64BufferPartDataType_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyI64BufferPartDataType_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyI64BufferPartDataType_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *,mvIMPACT::acquire::TBufferPartDataType,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *,mvIMPACT::acquire::TBufferPartDataType)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *,std::vector< mvIMPACT::acquire::TBufferPartDataType > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *,std::vector< mvIMPACT::acquire::TBufferPartDataType > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *,std::vector< mvIMPACT::acquire::TBufferPartDataType > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > const *,std::vector< mvIMPACT::acquire::TBufferPartDataType > const &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_PropertyI64BufferPartDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< 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__EnumPropertyIT_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::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_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_PropertyIImageBufferFormatReinterpreterMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIImageBufferFormatReinterpreterMode",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyIImageBufferFormatReinterpreterMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIImageBufferFormatReinterpreterMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIImageBufferFormatReinterpreterMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIImageBufferFormatReinterpreterMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIImageBufferFormatReinterpreterMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > &""'"); }
  
  arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > * >(argp2);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictString(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageBufferFormatReinterpreterMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) {
    return _wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictString__SWIG_0(self, argc, argv);}
   fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageBufferFormatReinterpreterMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageBufferFormatReinterpreterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageBufferFormatReinterpreterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) {
    return _wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValue__SWIG_0(self, argc, argv);} 
  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIImageBufferFormatReinterpreterMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIImageBufferFormatReinterpreterMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageBufferFormatReinterpreterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageBufferFormatReinterpreterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageBufferFormatReinterpreterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageBufferFormatReinterpreterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageBufferFormatReinterpreterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->read(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_read(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageBufferFormatReinterpreterMode_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIImageBufferFormatReinterpreterMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageBufferFormatReinterpreterMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *,std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *,std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *,std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *,std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *,std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *,std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode> * const pV = new std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode> * const pV = new std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode> * const pV = new std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode> * const pV = new std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageBufferFormatReinterpreterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageBufferFormatReinterpreterMode_write(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageBufferFormatReinterpreterMode_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIImageBufferFormatReinterpreterMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageBufferFormatReinterpreterMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *,std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *,std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *,std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const *,std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > const &,bool)\n");
  return NULL; }
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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIImageDestinationPixelFormat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[2]; if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIImageDestinationPixelFormat",0,1,argv))) SWIG_fail;
  --argc; if (argc == 0) { return _wrap_new_PropertyIImageDestinationPixelFormat__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIImageDestinationPixelFormat__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIImageDestinationPixelFormat'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIImageDestinationPixelFormat_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIImageDestinationPixelFormat_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > > * >(argp2);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIImageDestinationPixelFormat_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_getTranslationDictString(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageDestinationPixelFormat_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIImageDestinationPixelFormat_getTranslationDictString__SWIG_1(self, argc, argv);}
   if (argc == 2) { return _wrap_PropertyIImageDestinationPixelFormat_getTranslationDictString__SWIG_0(self, argc, argv);} 
  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageDestinationPixelFormat_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageDestinationPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageDestinationPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_getTranslationDictValue(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageDestinationPixelFormat_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIImageDestinationPixelFormat_getTranslationDictValue__SWIG_1(self, argc, argv);}
   if (argc == 2) { return _wrap_PropertyIImageDestinationPixelFormat_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageDestinationPixelFormat_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIImageDestinationPixelFormat_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIImageDestinationPixelFormat_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageDestinationPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageDestinationPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageDestinationPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageDestinationPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageDestinationPixelFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_read(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageDestinationPixelFormat_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIImageDestinationPixelFormat_read__SWIG_1(self, argc, argv);}  if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIImageDestinationPixelFormat_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIImageDestinationPixelFormat_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageDestinationPixelFormat_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIImageDestinationPixelFormat_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIImageDestinationPixelFormat_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIImageDestinationPixelFormat_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIImageDestinationPixelFormat_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageDestinationPixelFormat_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *,std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *,std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *,std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *,std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *,std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *,std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIImageDestinationPixelFormat_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIImageDestinationPixelFormat_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat> * const pV = new std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageDestinationPixelFormat,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat> * const pV = new std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageDestinationPixelFormat,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat> * const pV = new std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageDestinationPixelFormat,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat> * const pV = new std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageDestinationPixelFormat>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageDestinationPixelFormat,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageDestinationPixelFormat_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageDestinationPixelFormat_write(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageDestinationPixelFormat_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIImageDestinationPixelFormat_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIImageDestinationPixelFormat_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIImageDestinationPixelFormat_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; {
      { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageDestinationPixelFormat_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIImageDestinationPixelFormat_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIImageDestinationPixelFormat_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageDestinationPixelFormat_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *,mvIMPACT::acquire::TImageDestinationPixelFormat,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *,mvIMPACT::acquire::TImageDestinationPixelFormat)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *,std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *,std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *,std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat > const *,std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIImageProcessingFilter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIImageProcessingFilter",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIImageProcessingFilter__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIImageProcessingFilter__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIImageProcessingFilter'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIImageProcessingFilter_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIImageProcessingFilter_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIImageProcessingFilter_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageProcessingFilter_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIImageProcessingFilter_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIImageProcessingFilter_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageProcessingFilter_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingFilter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingFilter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageProcessingFilter_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIImageProcessingFilter_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIImageProcessingFilter_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageProcessingFilter_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIImageProcessingFilter_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIImageProcessingFilter_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingFilter> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingFilter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingFilter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingFilter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingFilter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingFilter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->read(*arg2,arg3,arg4); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingFilter> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->read(*arg2,arg3,arg4); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageProcessingFilter_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIImageProcessingFilter_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; {
      { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIImageProcessingFilter_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIImageProcessingFilter_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageProcessingFilter_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIImageProcessingFilter_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIImageProcessingFilter_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIImageProcessingFilter_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIImageProcessingFilter_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageProcessingFilter_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *,std::vector< mvIMPACT::acquire::TImageProcessingFilter > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *,std::vector< mvIMPACT::acquire::TImageProcessingFilter > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *,std::vector< mvIMPACT::acquire::TImageProcessingFilter > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *,std::vector< mvIMPACT::acquire::TImageProcessingFilter > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *,std::vector< mvIMPACT::acquire::TImageProcessingFilter > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *,std::vector< mvIMPACT::acquire::TImageProcessingFilter > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIImageProcessingFilter_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIImageProcessingFilter_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageProcessingFilter> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingFilter> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageProcessingFilter>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageProcessingFilter,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingFilter > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageProcessingFilter> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingFilter> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageProcessingFilter>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageProcessingFilter,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingFilter > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageProcessingFilter> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingFilter> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageProcessingFilter>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageProcessingFilter,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingFilter > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageProcessingFilter> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingFilter> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageProcessingFilter>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageProcessingFilter,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingFilter > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingFilter_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageProcessingFilter_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIImageProcessingFilter_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIImageProcessingFilter_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIImageProcessingFilter_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageProcessingFilter_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIImageProcessingFilter_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIImageProcessingFilter_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageProcessingFilter_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *,mvIMPACT::acquire::TImageProcessingFilter,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *,mvIMPACT::acquire::TImageProcessingFilter)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *,std::vector< mvIMPACT::acquire::TImageProcessingFilter > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *,std::vector< mvIMPACT::acquire::TImageProcessingFilter > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *,std::vector< mvIMPACT::acquire::TImageProcessingFilter > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter > const *,std::vector< mvIMPACT::acquire::TImageProcessingFilter > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIImageProcessingMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIImageProcessingMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIImageProcessingMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIImageProcessingMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIImageProcessingMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIImageProcessingMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIImageProcessingMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIImageProcessingMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageProcessingMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIImageProcessingMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIImageProcessingMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageProcessingMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageProcessingMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIImageProcessingMode_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIImageProcessingMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageProcessingMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIImageProcessingMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIImageProcessingMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageProcessingMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIImageProcessingMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIImageProcessingMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIImageProcessingMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageProcessingMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIImageProcessingMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIImageProcessingMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIImageProcessingMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIImageProcessingMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageProcessingMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *,std::vector< mvIMPACT::acquire::TImageProcessingMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *,std::vector< mvIMPACT::acquire::TImageProcessingMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *,std::vector< mvIMPACT::acquire::TImageProcessingMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *,std::vector< mvIMPACT::acquire::TImageProcessingMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *,std::vector< mvIMPACT::acquire::TImageProcessingMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *,std::vector< mvIMPACT::acquire::TImageProcessingMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIImageProcessingMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIImageProcessingMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageProcessingMode> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageProcessingMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageProcessingMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageProcessingMode> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageProcessingMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageProcessingMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageProcessingMode> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageProcessingMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageProcessingMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageProcessingMode> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageProcessingMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageProcessingMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageProcessingMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIImageProcessingMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIImageProcessingMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIImageProcessingMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageProcessingMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIImageProcessingMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIImageProcessingMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageProcessingMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *,mvIMPACT::acquire::TImageProcessingMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *,mvIMPACT::acquire::TImageProcessingMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *,std::vector< mvIMPACT::acquire::TImageProcessingMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *,std::vector< mvIMPACT::acquire::TImageProcessingMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *,std::vector< mvIMPACT::acquire::TImageProcessingMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode > const *,std::vector< mvIMPACT::acquire::TImageProcessingMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIImageProcessingOptimization__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[2]; if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIImageProcessingOptimization",0,1,argv))) SWIG_fail;
  --argc; if (argc == 0) { return _wrap_new_PropertyIImageProcessingOptimization__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIImageProcessingOptimization__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIImageProcessingOptimization'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIImageProcessingOptimization_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIImageProcessingOptimization_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > > * >(argp2);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIImageProcessingOptimization_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_getTranslationDictString(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageProcessingOptimization_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIImageProcessingOptimization_getTranslationDictString__SWIG_1(self, argc, argv);}
   if (argc == 2) { return _wrap_PropertyIImageProcessingOptimization_getTranslationDictString__SWIG_0(self, argc, argv);} 
  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageProcessingOptimization_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingOptimization)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingOptimization)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_getTranslationDictValue(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageProcessingOptimization_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIImageProcessingOptimization_getTranslationDictValue__SWIG_1(self, argc, argv);}
   if (argc == 2) { return _wrap_PropertyIImageProcessingOptimization_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageProcessingOptimization_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIImageProcessingOptimization_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIImageProcessingOptimization_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingOptimization> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingOptimization)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingOptimization)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingOptimization)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingOptimization)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingOptimization)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingOptimization> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_read(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageProcessingOptimization_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIImageProcessingOptimization_read__SWIG_1(self, argc, argv);}  if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIImageProcessingOptimization_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIImageProcessingOptimization_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageProcessingOptimization_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIImageProcessingOptimization_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIImageProcessingOptimization_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIImageProcessingOptimization_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIImageProcessingOptimization_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageProcessingOptimization_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *,std::vector< mvIMPACT::acquire::TImageProcessingOptimization > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *,std::vector< mvIMPACT::acquire::TImageProcessingOptimization > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *,std::vector< mvIMPACT::acquire::TImageProcessingOptimization > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *,std::vector< mvIMPACT::acquire::TImageProcessingOptimization > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *,std::vector< mvIMPACT::acquire::TImageProcessingOptimization > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *,std::vector< mvIMPACT::acquire::TImageProcessingOptimization > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIImageProcessingOptimization_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIImageProcessingOptimization_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageProcessingOptimization> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingOptimization> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageProcessingOptimization>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageProcessingOptimization,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingOptimization > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageProcessingOptimization> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingOptimization> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageProcessingOptimization>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageProcessingOptimization,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingOptimization > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageProcessingOptimization> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingOptimization> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageProcessingOptimization>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageProcessingOptimization,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingOptimization > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageProcessingOptimization> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingOptimization> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageProcessingOptimization>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageProcessingOptimization,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingOptimization > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingOptimization_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingOptimization_write(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageProcessingOptimization_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIImageProcessingOptimization_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIImageProcessingOptimization_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIImageProcessingOptimization_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; {
      { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageProcessingOptimization_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIImageProcessingOptimization_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIImageProcessingOptimization_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageProcessingOptimization_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *,mvIMPACT::acquire::TImageProcessingOptimization,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *,mvIMPACT::acquire::TImageProcessingOptimization)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *,std::vector< mvIMPACT::acquire::TImageProcessingOptimization > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *,std::vector< mvIMPACT::acquire::TImageProcessingOptimization > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *,std::vector< mvIMPACT::acquire::TImageProcessingOptimization > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization > const *,std::vector< mvIMPACT::acquire::TImageProcessingOptimization > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIImageProcessingResult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIImageProcessingResult",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIImageProcessingResult__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIImageProcessingResult__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIImageProcessingResult'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIImageProcessingResult_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIImageProcessingResult_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageProcessingResult_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIImageProcessingResult_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIImageProcessingResult_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageProcessingResult_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageProcessingResult_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIImageProcessingResult_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIImageProcessingResult_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageProcessingResult_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIImageProcessingResult_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIImageProcessingResult_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingResult> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageProcessingResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->read(*arg2,arg3,arg4); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingResult> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->read(*arg2,arg3,arg4); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageProcessingResult_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIImageProcessingResult_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; {
      { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIImageProcessingResult_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIImageProcessingResult_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageProcessingResult_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIImageProcessingResult_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIImageProcessingResult_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIImageProcessingResult_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIImageProcessingResult_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageProcessingResult_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *,std::vector< mvIMPACT::acquire::TImageProcessingResult > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *,std::vector< mvIMPACT::acquire::TImageProcessingResult > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *,std::vector< mvIMPACT::acquire::TImageProcessingResult > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *,std::vector< mvIMPACT::acquire::TImageProcessingResult > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *,std::vector< mvIMPACT::acquire::TImageProcessingResult > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *,std::vector< mvIMPACT::acquire::TImageProcessingResult > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageProcessingResult> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingResult> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageProcessingResult>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageProcessingResult,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingResult > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageProcessingResult> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingResult> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageProcessingResult>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageProcessingResult,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingResult > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageProcessingResult> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingResult> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageProcessingResult>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageProcessingResult,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingResult > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageProcessingResult> * const pV = new std::vector<mvIMPACT::acquire::TImageProcessingResult> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageProcessingResult>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageProcessingResult,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageProcessingResult > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingResult_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageProcessingResult_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageProcessingResult_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIImageProcessingResult_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIImageProcessingResult_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIImageProcessingResult_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageProcessingResult_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIImageProcessingResult_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIImageProcessingResult_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageProcessingResult_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *,mvIMPACT::acquire::TImageProcessingResult,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *,mvIMPACT::acquire::TImageProcessingResult)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *,std::vector< mvIMPACT::acquire::TImageProcessingResult > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *,std::vector< mvIMPACT::acquire::TImageProcessingResult > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *,std::vector< mvIMPACT::acquire::TImageProcessingResult > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult > const *,std::vector< mvIMPACT::acquire::TImageProcessingResult > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIRequestImageMemoryMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIRequestImageMemoryMode",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyIRequestImageMemoryMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIRequestImageMemoryMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIRequestImageMemoryMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIRequestImageMemoryMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIRequestImageMemoryMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIRequestImageMemoryMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIRequestImageMemoryMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIRequestImageMemoryMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIRequestImageMemoryMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIRequestImageMemoryMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRequestImageMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRequestImageMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIRequestImageMemoryMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIRequestImageMemoryMode_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIRequestImageMemoryMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIRequestImageMemoryMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIRequestImageMemoryMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIRequestImageMemoryMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TRequestImageMemoryMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRequestImageMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRequestImageMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRequestImageMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRequestImageMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRequestImageMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TRequestImageMemoryMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIRequestImageMemoryMode_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIRequestImageMemoryMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; {
      { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIRequestImageMemoryMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIRequestImageMemoryMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIRequestImageMemoryMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIRequestImageMemoryMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIRequestImageMemoryMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIRequestImageMemoryMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIRequestImageMemoryMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIRequestImageMemoryMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *,std::vector< mvIMPACT::acquire::TRequestImageMemoryMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *,std::vector< mvIMPACT::acquire::TRequestImageMemoryMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *,std::vector< mvIMPACT::acquire::TRequestImageMemoryMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *,std::vector< mvIMPACT::acquire::TRequestImageMemoryMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *,std::vector< mvIMPACT::acquire::TRequestImageMemoryMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *,std::vector< mvIMPACT::acquire::TRequestImageMemoryMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIRequestImageMemoryMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIRequestImageMemoryMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TRequestImageMemoryMode> * const pV = new std::vector<mvIMPACT::acquire::TRequestImageMemoryMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TRequestImageMemoryMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TRequestImageMemoryMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestImageMemoryMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TRequestImageMemoryMode> * const pV = new std::vector<mvIMPACT::acquire::TRequestImageMemoryMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TRequestImageMemoryMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TRequestImageMemoryMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestImageMemoryMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TRequestImageMemoryMode> * const pV = new std::vector<mvIMPACT::acquire::TRequestImageMemoryMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TRequestImageMemoryMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TRequestImageMemoryMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestImageMemoryMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TRequestImageMemoryMode> * const pV = new std::vector<mvIMPACT::acquire::TRequestImageMemoryMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TRequestImageMemoryMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TRequestImageMemoryMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestImageMemoryMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestImageMemoryMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestImageMemoryMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIRequestImageMemoryMode_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIRequestImageMemoryMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIRequestImageMemoryMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIRequestImageMemoryMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIRequestImageMemoryMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIRequestImageMemoryMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIRequestImageMemoryMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIRequestImageMemoryMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *,mvIMPACT::acquire::TRequestImageMemoryMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *,mvIMPACT::acquire::TRequestImageMemoryMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *,std::vector< mvIMPACT::acquire::TRequestImageMemoryMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *,std::vector< mvIMPACT::acquire::TRequestImageMemoryMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *,std::vector< mvIMPACT::acquire::TRequestImageMemoryMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode > const *,std::vector< mvIMPACT::acquire::TRequestImageMemoryMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIImageRequestControlMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIImageRequestControlMode",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyIImageRequestControlMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIImageRequestControlMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIImageRequestControlMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIImageRequestControlMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIImageRequestControlMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIImageRequestControlMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageRequestControlMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIImageRequestControlMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIImageRequestControlMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageRequestControlMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageRequestControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageRequestControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageRequestControlMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIImageRequestControlMode_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIImageRequestControlMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageRequestControlMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIImageRequestControlMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIImageRequestControlMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TImageRequestControlMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageRequestControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageRequestControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageRequestControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageRequestControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TImageRequestControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->read(*arg2,arg3); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TImageRequestControlMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->read(*arg2,arg3); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageRequestControlMode_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIImageRequestControlMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0;
    { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIImageRequestControlMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIImageRequestControlMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageRequestControlMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIImageRequestControlMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIImageRequestControlMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIImageRequestControlMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIImageRequestControlMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageRequestControlMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *,std::vector< mvIMPACT::acquire::TImageRequestControlMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *,std::vector< mvIMPACT::acquire::TImageRequestControlMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *,std::vector< mvIMPACT::acquire::TImageRequestControlMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *,std::vector< mvIMPACT::acquire::TImageRequestControlMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *,std::vector< mvIMPACT::acquire::TImageRequestControlMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *,std::vector< mvIMPACT::acquire::TImageRequestControlMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIImageRequestControlMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIImageRequestControlMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageRequestControlMode> * const pV = new std::vector<mvIMPACT::acquire::TImageRequestControlMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageRequestControlMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageRequestControlMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageRequestControlMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageRequestControlMode> * const pV = new std::vector<mvIMPACT::acquire::TImageRequestControlMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageRequestControlMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageRequestControlMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageRequestControlMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageRequestControlMode> * const pV = new std::vector<mvIMPACT::acquire::TImageRequestControlMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageRequestControlMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageRequestControlMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageRequestControlMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TImageRequestControlMode> * const pV = new std::vector<mvIMPACT::acquire::TImageRequestControlMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TImageRequestControlMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TImageRequestControlMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TImageRequestControlMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageRequestControlMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIImageRequestControlMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIImageRequestControlMode_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIImageRequestControlMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIImageRequestControlMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIImageRequestControlMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIImageRequestControlMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIImageRequestControlMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIImageRequestControlMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIImageRequestControlMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *,mvIMPACT::acquire::TImageRequestControlMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *,mvIMPACT::acquire::TImageRequestControlMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *,std::vector< mvIMPACT::acquire::TImageRequestControlMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *,std::vector< mvIMPACT::acquire::TImageRequestControlMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *,std::vector< mvIMPACT::acquire::TImageRequestControlMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode > const *,std::vector< mvIMPACT::acquire::TImageRequestControlMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyILUTGammaMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyILUTGammaMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyILUTGammaMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyILUTGammaMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyILUTGammaMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyILUTGammaMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyILUTGammaMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyILUTGammaMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILUTGammaMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyILUTGammaMode_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyILUTGammaMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILUTGammaMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTGammaMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTGammaMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILUTGammaMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyILUTGammaMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyILUTGammaMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILUTGammaMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyILUTGammaMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyILUTGammaMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TLUTGammaMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTGammaMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTGammaMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTGammaMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTGammaMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTGammaMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TLUTGammaMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILUTGammaMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyILUTGammaMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyILUTGammaMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyILUTGammaMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyILUTGammaMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyILUTGammaMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyILUTGammaMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyILUTGammaMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyILUTGammaMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILUTGammaMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *,std::vector< mvIMPACT::acquire::TLUTGammaMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *,std::vector< mvIMPACT::acquire::TLUTGammaMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *,std::vector< mvIMPACT::acquire::TLUTGammaMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *,std::vector< mvIMPACT::acquire::TLUTGammaMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *,std::vector< mvIMPACT::acquire::TLUTGammaMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *,std::vector< mvIMPACT::acquire::TLUTGammaMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyILUTGammaMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyILUTGammaMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLUTGammaMode> * const pV = new std::vector<mvIMPACT::acquire::TLUTGammaMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLUTGammaMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLUTGammaMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTGammaMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLUTGammaMode> * const pV = new std::vector<mvIMPACT::acquire::TLUTGammaMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLUTGammaMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLUTGammaMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTGammaMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLUTGammaMode> * const pV = new std::vector<mvIMPACT::acquire::TLUTGammaMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLUTGammaMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLUTGammaMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTGammaMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLUTGammaMode> * const pV = new std::vector<mvIMPACT::acquire::TLUTGammaMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLUTGammaMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLUTGammaMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTGammaMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTGammaMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILUTGammaMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyILUTGammaMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyILUTGammaMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyILUTGammaMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyILUTGammaMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyILUTGammaMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyILUTGammaMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILUTGammaMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *,mvIMPACT::acquire::TLUTGammaMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *,mvIMPACT::acquire::TLUTGammaMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *,std::vector< mvIMPACT::acquire::TLUTGammaMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *,std::vector< mvIMPACT::acquire::TLUTGammaMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *,std::vector< mvIMPACT::acquire::TLUTGammaMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode > const *,std::vector< mvIMPACT::acquire::TLUTGammaMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyILUTImplementation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyILUTImplementation",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyILUTImplementation__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyILUTImplementation__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyILUTImplementation'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyILUTImplementation_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyILUTImplementation_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyILUTImplementation_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILUTImplementation_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyILUTImplementation_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyILUTImplementation_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILUTImplementation_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTImplementation)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTImplementation)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILUTImplementation_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyILUTImplementation_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyILUTImplementation_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILUTImplementation_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyILUTImplementation_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyILUTImplementation_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TLUTImplementation> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTImplementation)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTImplementation)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTImplementation)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTImplementation)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTImplementation)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TLUTImplementation> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILUTImplementation_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyILUTImplementation_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyILUTImplementation_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyILUTImplementation_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyILUTImplementation_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyILUTImplementation_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyILUTImplementation_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyILUTImplementation_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyILUTImplementation_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILUTImplementation_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *,std::vector< mvIMPACT::acquire::TLUTImplementation > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *,std::vector< mvIMPACT::acquire::TLUTImplementation > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *,std::vector< mvIMPACT::acquire::TLUTImplementation > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *,std::vector< mvIMPACT::acquire::TLUTImplementation > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *,std::vector< mvIMPACT::acquire::TLUTImplementation > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *,std::vector< mvIMPACT::acquire::TLUTImplementation > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyILUTImplementation_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyILUTImplementation_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLUTImplementation> * const pV = new std::vector<mvIMPACT::acquire::TLUTImplementation> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLUTImplementation>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLUTImplementation,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTImplementation > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLUTImplementation> * const pV = new std::vector<mvIMPACT::acquire::TLUTImplementation> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLUTImplementation>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLUTImplementation,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTImplementation > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLUTImplementation> * const pV = new std::vector<mvIMPACT::acquire::TLUTImplementation> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLUTImplementation>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLUTImplementation,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTImplementation > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLUTImplementation> * const pV = new std::vector<mvIMPACT::acquire::TLUTImplementation> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLUTImplementation>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLUTImplementation,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTImplementation > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTImplementation_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTImplementation_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILUTImplementation_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyILUTImplementation_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyILUTImplementation_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyILUTImplementation_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyILUTImplementation_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyILUTImplementation_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyILUTImplementation_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILUTImplementation_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *,mvIMPACT::acquire::TLUTImplementation,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *,mvIMPACT::acquire::TLUTImplementation)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *,std::vector< mvIMPACT::acquire::TLUTImplementation > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *,std::vector< mvIMPACT::acquire::TLUTImplementation > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *,std::vector< mvIMPACT::acquire::TLUTImplementation > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation > const *,std::vector< mvIMPACT::acquire::TLUTImplementation > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyILUTInterpolationMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyILUTInterpolationMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyILUTInterpolationMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyILUTInterpolationMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyILUTInterpolationMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyILUTInterpolationMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyILUTInterpolationMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyILUTInterpolationMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILUTInterpolationMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyILUTInterpolationMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyILUTInterpolationMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILUTInterpolationMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILUTInterpolationMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyILUTInterpolationMode_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyILUTInterpolationMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILUTInterpolationMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyILUTInterpolationMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyILUTInterpolationMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TLUTInterpolationMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->read(*arg2,arg3,arg4); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TLUTInterpolationMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->read(*arg2,arg3,arg4); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILUTInterpolationMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyILUTInterpolationMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyILUTInterpolationMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyILUTInterpolationMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyILUTInterpolationMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyILUTInterpolationMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyILUTInterpolationMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyILUTInterpolationMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyILUTInterpolationMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILUTInterpolationMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *,std::vector< mvIMPACT::acquire::TLUTInterpolationMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *,std::vector< mvIMPACT::acquire::TLUTInterpolationMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *,std::vector< mvIMPACT::acquire::TLUTInterpolationMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *,std::vector< mvIMPACT::acquire::TLUTInterpolationMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *,std::vector< mvIMPACT::acquire::TLUTInterpolationMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *,std::vector< mvIMPACT::acquire::TLUTInterpolationMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyILUTInterpolationMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyILUTInterpolationMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLUTInterpolationMode> * const pV = new std::vector<mvIMPACT::acquire::TLUTInterpolationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLUTInterpolationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLUTInterpolationMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTInterpolationMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLUTInterpolationMode> * const pV = new std::vector<mvIMPACT::acquire::TLUTInterpolationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLUTInterpolationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLUTInterpolationMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTInterpolationMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLUTInterpolationMode> * const pV = new std::vector<mvIMPACT::acquire::TLUTInterpolationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLUTInterpolationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLUTInterpolationMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTInterpolationMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLUTInterpolationMode> * const pV = new std::vector<mvIMPACT::acquire::TLUTInterpolationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLUTInterpolationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLUTInterpolationMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTInterpolationMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTInterpolationMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILUTInterpolationMode_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyILUTInterpolationMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyILUTInterpolationMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyILUTInterpolationMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyILUTInterpolationMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyILUTInterpolationMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyILUTInterpolationMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILUTInterpolationMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *,mvIMPACT::acquire::TLUTInterpolationMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *,mvIMPACT::acquire::TLUTInterpolationMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *,std::vector< mvIMPACT::acquire::TLUTInterpolationMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *,std::vector< mvIMPACT::acquire::TLUTInterpolationMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *,std::vector< mvIMPACT::acquire::TLUTInterpolationMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode > const *,std::vector< mvIMPACT::acquire::TLUTInterpolationMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyILUTMapping__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyILUTMapping",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyILUTMapping__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyILUTMapping__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyILUTMapping'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyILUTMapping_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTMapping > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyILUTMapping_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTMapping > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTMapping > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyILUTMapping_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILUTMapping_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyILUTMapping_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyILUTMapping_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILUTMapping_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTMapping)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTMapping)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILUTMapping_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyILUTMapping_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyILUTMapping_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILUTMapping_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyILUTMapping_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyILUTMapping_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TLUTMapping> (0); arg2 = pV; } 
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTMapping)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTMapping)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTMapping)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTMapping)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTMapping)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TLUTMapping> (0); arg2 = pV; } 
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->read(*arg2,arg3,arg4,arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILUTMapping_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyILUTMapping_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyILUTMapping_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyILUTMapping_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyILUTMapping_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyILUTMapping_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyILUTMapping_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyILUTMapping_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyILUTMapping_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILUTMapping_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *,std::vector< mvIMPACT::acquire::TLUTMapping > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *,std::vector< mvIMPACT::acquire::TLUTMapping > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *,std::vector< mvIMPACT::acquire::TLUTMapping > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *,std::vector< mvIMPACT::acquire::TLUTMapping > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *,std::vector< mvIMPACT::acquire::TLUTMapping > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *,std::vector< mvIMPACT::acquire::TLUTMapping > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyILUTMapping_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyILUTMapping_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLUTMapping> * const pV = new std::vector<mvIMPACT::acquire::TLUTMapping> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLUTMapping>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLUTMapping,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTMapping > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLUTMapping> * const pV = new std::vector<mvIMPACT::acquire::TLUTMapping> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLUTMapping>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLUTMapping,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTMapping > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLUTMapping> * const pV = new std::vector<mvIMPACT::acquire::TLUTMapping> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLUTMapping>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLUTMapping,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTMapping > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLUTMapping> * const pV = new std::vector<mvIMPACT::acquire::TLUTMapping> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLUTMapping>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLUTMapping,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTMapping > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMapping_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMapping_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILUTMapping_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyILUTMapping_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyILUTMapping_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; return _wrap_PropertyILUTMapping_write__SWIG_2(self, argc, argv);}
   check_3: if (argc == 3) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyILUTMapping_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyILUTMapping_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyILUTMapping_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILUTMapping_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *,mvIMPACT::acquire::TLUTMapping,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *,mvIMPACT::acquire::TLUTMapping)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *,std::vector< mvIMPACT::acquire::TLUTMapping > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *,std::vector< mvIMPACT::acquire::TLUTMapping > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *,std::vector< mvIMPACT::acquire::TLUTMapping > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping > const *,std::vector< mvIMPACT::acquire::TLUTMapping > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyILUTMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyILUTMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyILUTMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyILUTMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyILUTMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyILUTMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyILUTMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyILUTMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->getTranslationDictString(); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILUTMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyILUTMode_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyILUTMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILUTMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3]; if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILUTMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyILUTMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyILUTMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILUTMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyILUTMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyILUTMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TLUTMode> (0); arg2 = pV; }  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLUTMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TLUTMode> (0); arg2 = pV; }  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILUTMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyILUTMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2; return _wrap_PropertyILUTMode_read__SWIG_4(self, argc, argv);} 
  check_2: if (argc == 2) { return _wrap_PropertyILUTMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyILUTMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyILUTMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyILUTMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyILUTMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyILUTMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILUTMode_read'.\n"
  "  Possible C/C++ prototypes are:\n" "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *,std::vector< mvIMPACT::acquire::TLUTMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *,std::vector< mvIMPACT::acquire::TLUTMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *,std::vector< mvIMPACT::acquire::TLUTMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *,std::vector< mvIMPACT::acquire::TLUTMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *,std::vector< mvIMPACT::acquire::TLUTMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *,std::vector< mvIMPACT::acquire::TLUTMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyILUTMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyILUTMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLUTMode> * const pV = new std::vector<mvIMPACT::acquire::TLUTMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLUTMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLUTMode,SWIG_POINTER_EXCEPTION) == -1) { SWIG_fail; }
       (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLUTMode> * const pV = new std::vector<mvIMPACT::acquire::TLUTMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLUTMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLUTMode,SWIG_POINTER_EXCEPTION) == -1) { SWIG_fail; }
       (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLUTMode> * const pV = new std::vector<mvIMPACT::acquire::TLUTMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLUTMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLUTMode,SWIG_POINTER_EXCEPTION) == -1) { SWIG_fail; }
       (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLUTMode> * const pV = new std::vector<mvIMPACT::acquire::TLUTMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLUTMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLUTMode,SWIG_POINTER_EXCEPTION) == -1) { SWIG_fail; }
       (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLUTMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILUTMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILUTMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0;
    { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyILUTMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyILUTMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; return _wrap_PropertyILUTMode_write__SWIG_2(self, argc, argv);} 
  check_3: if (argc == 3) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyILUTMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyILUTMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyILUTMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILUTMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *,mvIMPACT::acquire::TLUTMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *,mvIMPACT::acquire::TLUTMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *,std::vector< mvIMPACT::acquire::TLUTMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *,std::vector< mvIMPACT::acquire::TLUTMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *,std::vector< mvIMPACT::acquire::TLUTMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode > const *,std::vector< mvIMPACT::acquire::TLUTMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIMirrorMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIMirrorMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIMirrorMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIMirrorMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIMirrorMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIMirrorMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TMirrorMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIMirrorMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TMirrorMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TMirrorMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIMirrorMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIMirrorMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIMirrorMode_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIMirrorMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIMirrorMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMirrorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMirrorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIMirrorMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIMirrorMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIMirrorMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIMirrorMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIMirrorMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIMirrorMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TMirrorMode> (0); arg2 = pV; } 
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMirrorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMirrorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMirrorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMirrorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMirrorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TMirrorMode> (0); arg2 = pV; } 
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIMirrorMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIMirrorMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIMirrorMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIMirrorMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIMirrorMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIMirrorMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIMirrorMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIMirrorMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIMirrorMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIMirrorMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *,std::vector< mvIMPACT::acquire::TMirrorMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *,std::vector< mvIMPACT::acquire::TMirrorMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *,std::vector< mvIMPACT::acquire::TMirrorMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *,std::vector< mvIMPACT::acquire::TMirrorMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *,std::vector< mvIMPACT::acquire::TMirrorMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *,std::vector< mvIMPACT::acquire::TMirrorMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIMirrorMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIMirrorMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TMirrorMode> * const pV = new std::vector<mvIMPACT::acquire::TMirrorMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TMirrorMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TMirrorMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMirrorMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TMirrorMode> * const pV = new std::vector<mvIMPACT::acquire::TMirrorMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TMirrorMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TMirrorMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMirrorMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TMirrorMode> * const pV = new std::vector<mvIMPACT::acquire::TMirrorMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TMirrorMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TMirrorMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMirrorMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TMirrorMode> * const pV = new std::vector<mvIMPACT::acquire::TMirrorMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TMirrorMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TMirrorMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMirrorMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIMirrorMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIMirrorMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIMirrorMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; return _wrap_PropertyIMirrorMode_write__SWIG_2(self, argc, argv);}
   check_3: if (argc == 3) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIMirrorMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIMirrorMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIMirrorMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIMirrorMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *,mvIMPACT::acquire::TMirrorMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *,mvIMPACT::acquire::TMirrorMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *,std::vector< mvIMPACT::acquire::TMirrorMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *,std::vector< mvIMPACT::acquire::TMirrorMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *,std::vector< mvIMPACT::acquire::TMirrorMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode > const *,std::vector< mvIMPACT::acquire::TMirrorMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIMirrorOperationMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIMirrorOperationMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIMirrorOperationMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIMirrorOperationMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIMirrorOperationMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIMirrorOperationMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIMirrorOperationMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIMirrorOperationMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIMirrorOperationMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIMirrorOperationMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIMirrorOperationMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIMirrorOperationMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMirrorOperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMirrorOperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIMirrorOperationMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIMirrorOperationMode_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIMirrorOperationMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIMirrorOperationMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIMirrorOperationMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIMirrorOperationMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TMirrorOperationMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMirrorOperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMirrorOperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMirrorOperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMirrorOperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMirrorOperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TMirrorOperationMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIMirrorOperationMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIMirrorOperationMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIMirrorOperationMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIMirrorOperationMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIMirrorOperationMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIMirrorOperationMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIMirrorOperationMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIMirrorOperationMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIMirrorOperationMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIMirrorOperationMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *,std::vector< mvIMPACT::acquire::TMirrorOperationMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *,std::vector< mvIMPACT::acquire::TMirrorOperationMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *,std::vector< mvIMPACT::acquire::TMirrorOperationMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *,std::vector< mvIMPACT::acquire::TMirrorOperationMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *,std::vector< mvIMPACT::acquire::TMirrorOperationMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *,std::vector< mvIMPACT::acquire::TMirrorOperationMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIMirrorOperationMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIMirrorOperationMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TMirrorOperationMode> * const pV = new std::vector<mvIMPACT::acquire::TMirrorOperationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TMirrorOperationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TMirrorOperationMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMirrorOperationMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TMirrorOperationMode> * const pV = new std::vector<mvIMPACT::acquire::TMirrorOperationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TMirrorOperationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TMirrorOperationMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMirrorOperationMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TMirrorOperationMode> * const pV = new std::vector<mvIMPACT::acquire::TMirrorOperationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TMirrorOperationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TMirrorOperationMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMirrorOperationMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TMirrorOperationMode> * const pV = new std::vector<mvIMPACT::acquire::TMirrorOperationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TMirrorOperationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TMirrorOperationMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMirrorOperationMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMirrorOperationMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIMirrorOperationMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIMirrorOperationMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIMirrorOperationMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIMirrorOperationMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIMirrorOperationMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIMirrorOperationMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIMirrorOperationMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIMirrorOperationMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *,mvIMPACT::acquire::TMirrorOperationMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *,mvIMPACT::acquire::TMirrorOperationMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *,std::vector< mvIMPACT::acquire::TMirrorOperationMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *,std::vector< mvIMPACT::acquire::TMirrorOperationMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *,std::vector< mvIMPACT::acquire::TMirrorOperationMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode > const *,std::vector< mvIMPACT::acquire::TMirrorOperationMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIPolarizedDataExtractionMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[2]; if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIPolarizedDataExtractionMode",0,1,argv))) SWIG_fail;
  --argc; if (argc == 0) { return _wrap_new_PropertyIPolarizedDataExtractionMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIPolarizedDataExtractionMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIPolarizedDataExtractionMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIPolarizedDataExtractionMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIPolarizedDataExtractionMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > > * >(argp2);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIPolarizedDataExtractionMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictString(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIPolarizedDataExtractionMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictString__SWIG_1(self, argc, argv);}
   if (argc == 2) { return _wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictString__SWIG_0(self, argc, argv);} 
  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIPolarizedDataExtractionMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TPolarizedDataExtractionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TPolarizedDataExtractionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIPolarizedDataExtractionMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictValue__SWIG_1(self, argc, argv);}
   if (argc == 2) { return _wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIPolarizedDataExtractionMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIPolarizedDataExtractionMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIPolarizedDataExtractionMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TPolarizedDataExtractionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TPolarizedDataExtractionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TPolarizedDataExtractionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TPolarizedDataExtractionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TPolarizedDataExtractionMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_read(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIPolarizedDataExtractionMode_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIPolarizedDataExtractionMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIPolarizedDataExtractionMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *,std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *,std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *,std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *,std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *,std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *,std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIPolarizedDataExtractionMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIPolarizedDataExtractionMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode> * const pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TPolarizedDataExtractionMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode> * const pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TPolarizedDataExtractionMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode> * const pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TPolarizedDataExtractionMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode> * const pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TPolarizedDataExtractionMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TPolarizedDataExtractionMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionMode_write(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIPolarizedDataExtractionMode_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIPolarizedDataExtractionMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIPolarizedDataExtractionMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIPolarizedDataExtractionMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; {
      { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIPolarizedDataExtractionMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIPolarizedDataExtractionMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIPolarizedDataExtractionMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIPolarizedDataExtractionMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *,mvIMPACT::acquire::TPolarizedDataExtractionMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *,mvIMPACT::acquire::TPolarizedDataExtractionMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *,std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *,std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *,std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode > const *,std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIPolarizedDataExtractionInterpolationMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIPolarizedDataExtractionInterpolationMode",0,1,argv))) SWIG_fail;
  --argc; if (argc == 0) { return _wrap_new_PropertyIPolarizedDataExtractionInterpolationMode__SWIG_0(self, argc, argv);} 
  if (argc == 1) { return _wrap_new_PropertyIPolarizedDataExtractionInterpolationMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIPolarizedDataExtractionInterpolationMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ;
  void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > &""'"); }
  
  arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > * >(argp2);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictString(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) {
    return _wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) {
    return _wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) {
    return _wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) {
    return _wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->read(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_read(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIPolarizedDataExtractionInterpolationMode_read",0,5,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_1(self, argc, argv);} 
  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) {
    int _v = 0; { { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) {
    int _v = 0; { { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIPolarizedDataExtractionInterpolationMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIPolarizedDataExtractionInterpolationMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *,std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *,std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *,std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *,std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *,std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *,std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode> * const pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode> * const pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode> * const pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode> * const pV = new std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPolarizedDataExtractionInterpolationMode_write(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIPolarizedDataExtractionInterpolationMode_write",0,4,argv))) SWIG_fail;
  --argc; if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIPolarizedDataExtractionInterpolationMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIPolarizedDataExtractionInterpolationMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *,std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *,std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *,std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const *,std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > const &,bool)\n");
  return NULL; }
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);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIRequestResult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIRequestResult",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIRequestResult__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIRequestResult__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIRequestResult'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIRequestResult_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TRequestResult > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIRequestResult_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TRequestResult > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TRequestResult > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIRequestResult_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIRequestResult_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIRequestResult_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIRequestResult_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIRequestResult_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRequestResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRequestResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIRequestResult_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIRequestResult_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIRequestResult_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIRequestResult_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIRequestResult_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIRequestResult_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TRequestResult> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRequestResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRequestResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRequestResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRequestResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRequestResult)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TRequestResult> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->read(*arg2,arg3,arg4,arg5); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIRequestResult_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIRequestResult_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIRequestResult_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIRequestResult_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIRequestResult_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIRequestResult_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIRequestResult_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIRequestResult_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIRequestResult_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIRequestResult_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *,std::vector< mvIMPACT::acquire::TRequestResult > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *,std::vector< mvIMPACT::acquire::TRequestResult > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *,std::vector< mvIMPACT::acquire::TRequestResult > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *,std::vector< mvIMPACT::acquire::TRequestResult > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *,std::vector< mvIMPACT::acquire::TRequestResult > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *,std::vector< mvIMPACT::acquire::TRequestResult > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIRequestResult_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIRequestResult_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TRequestResult> * const pV = new std::vector<mvIMPACT::acquire::TRequestResult> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TRequestResult>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TRequestResult,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestResult > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TRequestResult> * const pV = new std::vector<mvIMPACT::acquire::TRequestResult> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TRequestResult>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TRequestResult,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestResult > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TRequestResult> * const pV = new std::vector<mvIMPACT::acquire::TRequestResult> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TRequestResult>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TRequestResult,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestResult > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TRequestResult> * const pV = new std::vector<mvIMPACT::acquire::TRequestResult> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TRequestResult>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TRequestResult,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestResult > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestResult_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIRequestResult_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIRequestResult_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIRequestResult_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIRequestResult_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIRequestResult_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIRequestResult_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIRequestResult_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIRequestResult_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *,mvIMPACT::acquire::TRequestResult,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *,mvIMPACT::acquire::TRequestResult)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *,std::vector< mvIMPACT::acquire::TRequestResult > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *,std::vector< mvIMPACT::acquire::TRequestResult > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *,std::vector< mvIMPACT::acquire::TRequestResult > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult > const *,std::vector< mvIMPACT::acquire::TRequestResult > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIRequestState__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIRequestState",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIRequestState__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIRequestState__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIRequestState'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIRequestState_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TRequestState > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIRequestState_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TRequestState > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TRequestState > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIRequestState_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIRequestState_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIRequestState_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIRequestState_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIRequestState_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRequestState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRequestState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIRequestState_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIRequestState_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIRequestState_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIRequestState_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIRequestState_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIRequestState_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TRequestState> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRequestState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRequestState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRequestState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRequestState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRequestState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TRequestState> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->read(*arg2,arg3,arg4,arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIRequestState_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIRequestState_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIRequestState_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIRequestState_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIRequestState_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIRequestState_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIRequestState_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIRequestState_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIRequestState_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIRequestState_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *,std::vector< mvIMPACT::acquire::TRequestState > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *,std::vector< mvIMPACT::acquire::TRequestState > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *,std::vector< mvIMPACT::acquire::TRequestState > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *,std::vector< mvIMPACT::acquire::TRequestState > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *,std::vector< mvIMPACT::acquire::TRequestState > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *,std::vector< mvIMPACT::acquire::TRequestState > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIRequestState_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIRequestState_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TRequestState> * const pV = new std::vector<mvIMPACT::acquire::TRequestState> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TRequestState>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TRequestState,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestState > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TRequestState> * const pV = new std::vector<mvIMPACT::acquire::TRequestState> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TRequestState>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TRequestState,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestState > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TRequestState> * const pV = new std::vector<mvIMPACT::acquire::TRequestState> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TRequestState>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TRequestState,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestState > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TRequestState> * const pV = new std::vector<mvIMPACT::acquire::TRequestState> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TRequestState>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TRequestState,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRequestState > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestState_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRequestState_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIRequestState_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIRequestState_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIRequestState_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIRequestState_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIRequestState_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIRequestState_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIRequestState_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIRequestState_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *,mvIMPACT::acquire::TRequestState,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *,mvIMPACT::acquire::TRequestState)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *,std::vector< mvIMPACT::acquire::TRequestState > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *,std::vector< mvIMPACT::acquire::TRequestState > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *,std::vector< mvIMPACT::acquire::TRequestState > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState > const *,std::vector< mvIMPACT::acquire::TRequestState > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIScalerMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIScalerMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIScalerMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIScalerMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIScalerMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIScalerMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TScalerMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIScalerMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TScalerMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TScalerMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIScalerMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIScalerMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIScalerMode_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIScalerMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIScalerMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScalerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScalerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIScalerMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIScalerMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIScalerMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIScalerMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIScalerMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIScalerMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TScalerMode> (0); arg2 = pV; } 
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScalerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScalerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScalerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScalerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScalerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TScalerMode> (0); arg2 = pV; } 
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIScalerMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIScalerMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIScalerMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIScalerMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIScalerMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIScalerMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIScalerMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIScalerMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIScalerMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIScalerMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *,std::vector< mvIMPACT::acquire::TScalerMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *,std::vector< mvIMPACT::acquire::TScalerMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *,std::vector< mvIMPACT::acquire::TScalerMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *,std::vector< mvIMPACT::acquire::TScalerMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *,std::vector< mvIMPACT::acquire::TScalerMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *,std::vector< mvIMPACT::acquire::TScalerMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIScalerMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIScalerMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TScalerMode> * const pV = new std::vector<mvIMPACT::acquire::TScalerMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TScalerMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TScalerMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScalerMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TScalerMode> * const pV = new std::vector<mvIMPACT::acquire::TScalerMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TScalerMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TScalerMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScalerMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TScalerMode> * const pV = new std::vector<mvIMPACT::acquire::TScalerMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TScalerMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TScalerMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScalerMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TScalerMode> * const pV = new std::vector<mvIMPACT::acquire::TScalerMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TScalerMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TScalerMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScalerMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIScalerMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIScalerMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIScalerMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; return _wrap_PropertyIScalerMode_write__SWIG_2(self, argc, argv);}
   check_3: if (argc == 3) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIScalerMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIScalerMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIScalerMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIScalerMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *,mvIMPACT::acquire::TScalerMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *,mvIMPACT::acquire::TScalerMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *,std::vector< mvIMPACT::acquire::TScalerMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *,std::vector< mvIMPACT::acquire::TScalerMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *,std::vector< mvIMPACT::acquire::TScalerMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode > const *,std::vector< mvIMPACT::acquire::TScalerMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIScalerInterpolationMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIScalerInterpolationMode",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyIScalerInterpolationMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIScalerInterpolationMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIScalerInterpolationMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIScalerInterpolationMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIScalerInterpolationMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIScalerInterpolationMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIScalerInterpolationMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIScalerInterpolationMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIScalerInterpolationMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIScalerInterpolationMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScalerInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScalerInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIScalerInterpolationMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIScalerInterpolationMode_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIScalerInterpolationMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIScalerInterpolationMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIScalerInterpolationMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIScalerInterpolationMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TScalerInterpolationMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScalerInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScalerInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScalerInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScalerInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScalerInterpolationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->read(*arg2,arg3); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TScalerInterpolationMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->read(*arg2,arg3); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIScalerInterpolationMode_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIScalerInterpolationMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0;
    { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIScalerInterpolationMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIScalerInterpolationMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIScalerInterpolationMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIScalerInterpolationMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIScalerInterpolationMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIScalerInterpolationMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIScalerInterpolationMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIScalerInterpolationMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *,std::vector< mvIMPACT::acquire::TScalerInterpolationMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *,std::vector< mvIMPACT::acquire::TScalerInterpolationMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *,std::vector< mvIMPACT::acquire::TScalerInterpolationMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *,std::vector< mvIMPACT::acquire::TScalerInterpolationMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *,std::vector< mvIMPACT::acquire::TScalerInterpolationMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *,std::vector< mvIMPACT::acquire::TScalerInterpolationMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIScalerInterpolationMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIScalerInterpolationMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TScalerInterpolationMode> * const pV = new std::vector<mvIMPACT::acquire::TScalerInterpolationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TScalerInterpolationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TScalerInterpolationMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScalerInterpolationMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TScalerInterpolationMode> * const pV = new std::vector<mvIMPACT::acquire::TScalerInterpolationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TScalerInterpolationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TScalerInterpolationMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScalerInterpolationMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TScalerInterpolationMode> * const pV = new std::vector<mvIMPACT::acquire::TScalerInterpolationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TScalerInterpolationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TScalerInterpolationMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScalerInterpolationMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TScalerInterpolationMode> * const pV = new std::vector<mvIMPACT::acquire::TScalerInterpolationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TScalerInterpolationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TScalerInterpolationMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScalerInterpolationMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScalerInterpolationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScalerInterpolationMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIScalerInterpolationMode_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIScalerInterpolationMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIScalerInterpolationMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIScalerInterpolationMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIScalerInterpolationMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIScalerInterpolationMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIScalerInterpolationMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIScalerInterpolationMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *,mvIMPACT::acquire::TScalerInterpolationMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *,mvIMPACT::acquire::TScalerInterpolationMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *,std::vector< mvIMPACT::acquire::TScalerInterpolationMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *,std::vector< mvIMPACT::acquire::TScalerInterpolationMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *,std::vector< mvIMPACT::acquire::TScalerInterpolationMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode > const *,std::vector< mvIMPACT::acquire::TScalerInterpolationMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIThreadPriority__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIThreadPriority__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *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_PropertyIThreadPriority" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIThreadPriority(PyObject *self, PyObject *args) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIThreadPriority",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIThreadPriority__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIThreadPriority__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIThreadPriority'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TThreadPriority > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args,"PropertyIThreadPriority_getTranslationDict",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TThreadPriority_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIThreadPriority_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TThreadPriority > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIThreadPriority_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TThreadPriority > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TThreadPriority > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 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__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIThreadPriority_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 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__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIThreadPriority_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIThreadPriority_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIThreadPriority_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIThreadPriority_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TThreadPriority result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIThreadPriority_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TThreadPriority)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TThreadPriority result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TThreadPriority)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIThreadPriority_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIThreadPriority_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIThreadPriority_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIThreadPriority_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 0 ;
  std::vector< std::string > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ;
  PyObject *swig_obj[2] ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args,"PropertyIThreadPriority_getTranslationDictStrings",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIThreadPriority_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIThreadPriority_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 0 ;
  std::vector< mvIMPACT::acquire::TThreadPriority > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args,"PropertyIThreadPriority_getTranslationDictValues",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TThreadPriority> * const pV = new std::vector<mvIMPACT::acquire::TThreadPriority> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TThreadPriority result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIThreadPriority_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TThreadPriority)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TThreadPriority result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TThreadPriority)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TThreadPriority result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TThreadPriority)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TThreadPriority result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TThreadPriority)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TThreadPriority result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TThreadPriority)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 0 ;
  std::vector< mvIMPACT::acquire::TThreadPriority > *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__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TThreadPriority> * const pV = new std::vector<mvIMPACT::acquire::TThreadPriority> (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIThreadPriority_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 '" "PropertyIThreadPriority_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 0 ;
  std::vector< mvIMPACT::acquire::TThreadPriority > *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__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TThreadPriority> * const pV = new std::vector<mvIMPACT::acquire::TThreadPriority> (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIThreadPriority_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 0 ;
  std::vector< mvIMPACT::acquire::TThreadPriority > *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__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TThreadPriority> * const pV = new std::vector<mvIMPACT::acquire::TThreadPriority> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 0 ;
  std::vector< mvIMPACT::acquire::TThreadPriority > *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__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TThreadPriority> * const pV = new std::vector<mvIMPACT::acquire::TThreadPriority> (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIThreadPriority_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 '" "PropertyIThreadPriority_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 '" "PropertyIThreadPriority_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->read(*arg2,arg3,arg4,arg5); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 0 ;
  std::vector< mvIMPACT::acquire::TThreadPriority > *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__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TThreadPriority> * const pV = new std::vector<mvIMPACT::acquire::TThreadPriority> (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIThreadPriority_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 '" "PropertyIThreadPriority_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 0 ;
  std::vector< mvIMPACT::acquire::TThreadPriority > *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__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TThreadPriority> * const pV = new std::vector<mvIMPACT::acquire::TThreadPriority> (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIThreadPriority_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIThreadPriority_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIThreadPriority_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIThreadPriority_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIThreadPriority_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIThreadPriority_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIThreadPriority_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIThreadPriority_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIThreadPriority_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIThreadPriority_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIThreadPriority_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *,std::vector< mvIMPACT::acquire::TThreadPriority > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *,std::vector< mvIMPACT::acquire::TThreadPriority > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *,std::vector< mvIMPACT::acquire::TThreadPriority > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *,std::vector< mvIMPACT::acquire::TThreadPriority > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *,std::vector< mvIMPACT::acquire::TThreadPriority > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *,std::vector< mvIMPACT::acquire::TThreadPriority > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 0 ;
  mvIMPACT::acquire::TThreadPriority arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIThreadPriority_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TThreadPriority""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TThreadPriority >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIThreadPriority_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 0 ;
  mvIMPACT::acquire::TThreadPriority arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIThreadPriority_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TThreadPriority""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TThreadPriority >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 0 ;
  std::vector< mvIMPACT::acquire::TThreadPriority > *arg2 = 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1); {
    if (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TThreadPriority> * const pV = new std::vector<mvIMPACT::acquire::TThreadPriority> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TThreadPriority>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TThreadPriority,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIThreadPriority_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->write((std::vector< mvIMPACT::acquire::TThreadPriority > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 0 ;
  std::vector< mvIMPACT::acquire::TThreadPriority > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1); {
    if (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TThreadPriority> * const pV = new std::vector<mvIMPACT::acquire::TThreadPriority> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TThreadPriority>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TThreadPriority,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->write((std::vector< mvIMPACT::acquire::TThreadPriority > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 0 ;
  std::vector< mvIMPACT::acquire::TThreadPriority > *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::TThreadPriority > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1); {
    if (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TThreadPriority> * const pV = new std::vector<mvIMPACT::acquire::TThreadPriority> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TThreadPriority>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TThreadPriority,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIThreadPriority_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 '" "PropertyIThreadPriority_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->write((std::vector< mvIMPACT::acquire::TThreadPriority > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 0 ;
  std::vector< mvIMPACT::acquire::TThreadPriority > *arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIThreadPriority_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1); {
    if (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TThreadPriority> * const pV = new std::vector<mvIMPACT::acquire::TThreadPriority> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TThreadPriority>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TThreadPriority,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIThreadPriority_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *)arg1)->write((std::vector< mvIMPACT::acquire::TThreadPriority > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIThreadPriority_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIThreadPriority_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIThreadPriority_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIThreadPriority_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIThreadPriority_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIThreadPriority_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIThreadPriority_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIThreadPriority_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIThreadPriority_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *,mvIMPACT::acquire::TThreadPriority,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *,mvIMPACT::acquire::TThreadPriority)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *,std::vector< mvIMPACT::acquire::TThreadPriority > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *,std::vector< mvIMPACT::acquire::TThreadPriority > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *,std::vector< mvIMPACT::acquire::TThreadPriority > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > const *,std::vector< mvIMPACT::acquire::TThreadPriority > const &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_PropertyIThreadPriority(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *) 0 ;
  void *argp1 = 0 ; int res1 = 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__TThreadPriority_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIThreadPriority" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIThreadPriority_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

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

SWIGINTERN PyObject *_wrap_new_PropertyIUserDataAccessRight__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIUserDataAccessRight",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIUserDataAccessRight__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIUserDataAccessRight__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIUserDataAccessRight'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIUserDataAccessRight_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIUserDataAccessRight_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIUserDataAccessRight_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIUserDataAccessRight_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIUserDataAccessRight_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIUserDataAccessRight_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIUserDataAccessRight_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TUserDataAccessRight)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TUserDataAccessRight)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIUserDataAccessRight_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIUserDataAccessRight_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIUserDataAccessRight_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIUserDataAccessRight_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIUserDataAccessRight_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIUserDataAccessRight_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TUserDataAccessRight> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TUserDataAccessRight)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TUserDataAccessRight)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TUserDataAccessRight)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TUserDataAccessRight)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TUserDataAccessRight)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TUserDataAccessRight> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIUserDataAccessRight_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIUserDataAccessRight_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIUserDataAccessRight_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIUserDataAccessRight_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIUserDataAccessRight_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIUserDataAccessRight_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIUserDataAccessRight_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIUserDataAccessRight_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIUserDataAccessRight_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIUserDataAccessRight_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *,std::vector< mvIMPACT::acquire::TUserDataAccessRight > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *,std::vector< mvIMPACT::acquire::TUserDataAccessRight > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *,std::vector< mvIMPACT::acquire::TUserDataAccessRight > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *,std::vector< mvIMPACT::acquire::TUserDataAccessRight > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *,std::vector< mvIMPACT::acquire::TUserDataAccessRight > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *,std::vector< mvIMPACT::acquire::TUserDataAccessRight > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIUserDataAccessRight_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIUserDataAccessRight_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TUserDataAccessRight> * const pV = new std::vector<mvIMPACT::acquire::TUserDataAccessRight> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TUserDataAccessRight>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TUserDataAccessRight,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->write((std::vector< mvIMPACT::acquire::TUserDataAccessRight > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TUserDataAccessRight> * const pV = new std::vector<mvIMPACT::acquire::TUserDataAccessRight> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TUserDataAccessRight>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TUserDataAccessRight,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->write((std::vector< mvIMPACT::acquire::TUserDataAccessRight > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TUserDataAccessRight> * const pV = new std::vector<mvIMPACT::acquire::TUserDataAccessRight> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TUserDataAccessRight>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TUserDataAccessRight,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->write((std::vector< mvIMPACT::acquire::TUserDataAccessRight > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TUserDataAccessRight> * const pV = new std::vector<mvIMPACT::acquire::TUserDataAccessRight> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TUserDataAccessRight>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TUserDataAccessRight,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *)arg1)->write((std::vector< mvIMPACT::acquire::TUserDataAccessRight > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataAccessRight_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataAccessRight_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIUserDataAccessRight_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIUserDataAccessRight_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIUserDataAccessRight_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIUserDataAccessRight_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIUserDataAccessRight_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIUserDataAccessRight_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIUserDataAccessRight_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIUserDataAccessRight_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *,mvIMPACT::acquire::TUserDataAccessRight,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *,mvIMPACT::acquire::TUserDataAccessRight)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *,std::vector< mvIMPACT::acquire::TUserDataAccessRight > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *,std::vector< mvIMPACT::acquire::TUserDataAccessRight > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *,std::vector< mvIMPACT::acquire::TUserDataAccessRight > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight > const *,std::vector< mvIMPACT::acquire::TUserDataAccessRight > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIUserDataReconnectBehaviour__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[2]; if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIUserDataReconnectBehaviour",0,1,argv))) SWIG_fail;
  --argc; if (argc == 0) { return _wrap_new_PropertyIUserDataReconnectBehaviour__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIUserDataReconnectBehaviour__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIUserDataReconnectBehaviour'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIUserDataReconnectBehaviour_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIUserDataReconnectBehaviour_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIUserDataReconnectBehaviour_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictString(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIUserDataReconnectBehaviour_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictString__SWIG_1(self, argc, argv);}
   if (argc == 2) { return _wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIUserDataReconnectBehaviour_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TUserDataReconnectBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TUserDataReconnectBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictValue(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIUserDataReconnectBehaviour_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIUserDataReconnectBehaviour_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIUserDataReconnectBehaviour_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIUserDataReconnectBehaviour_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TUserDataReconnectBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TUserDataReconnectBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TUserDataReconnectBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TUserDataReconnectBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TUserDataReconnectBehaviour)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->read(*arg2,arg3); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->read(*arg2,arg3); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_read(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[6]; if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIUserDataReconnectBehaviour_read",0,5,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_1(self, argc, argv);}  if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIUserDataReconnectBehaviour_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIUserDataReconnectBehaviour_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *,std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *,std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *,std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *,std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *,std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *,std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIUserDataReconnectBehaviour_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIUserDataReconnectBehaviour_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour> * const pV = new std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TUserDataReconnectBehaviour,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->write((std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour> * const pV = new std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TUserDataReconnectBehaviour,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->write((std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour> * const pV = new std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TUserDataReconnectBehaviour,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->write((std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour> * const pV = new std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TUserDataReconnectBehaviour>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TUserDataReconnectBehaviour,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *)arg1)->write((std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TUserDataReconnectBehaviour_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIUserDataReconnectBehaviour_write(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIUserDataReconnectBehaviour_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIUserDataReconnectBehaviour_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIUserDataReconnectBehaviour_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIUserDataReconnectBehaviour_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; {
      { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIUserDataReconnectBehaviour_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIUserDataReconnectBehaviour_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIUserDataReconnectBehaviour_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIUserDataReconnectBehaviour_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *,mvIMPACT::acquire::TUserDataReconnectBehaviour,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *,mvIMPACT::acquire::TUserDataReconnectBehaviour)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *,std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *,std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *,std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour > const *,std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIWhiteBalanceCalibrationMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[2]; if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIWhiteBalanceCalibrationMode",0,1,argv))) SWIG_fail;
  --argc; if (argc == 0) { return _wrap_new_PropertyIWhiteBalanceCalibrationMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIWhiteBalanceCalibrationMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIWhiteBalanceCalibrationMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIWhiteBalanceCalibrationMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIWhiteBalanceCalibrationMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > * >(argp2);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIWhiteBalanceCalibrationMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictString(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIWhiteBalanceCalibrationMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictString__SWIG_1(self, argc, argv);}
   if (argc == 2) { return _wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictString__SWIG_0(self, argc, argv);} 
  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIWhiteBalanceCalibrationMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TWhiteBalanceCalibrationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TWhiteBalanceCalibrationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictValue(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIWhiteBalanceCalibrationMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictValue__SWIG_1(self, argc, argv);}
   if (argc == 2) { return _wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIWhiteBalanceCalibrationMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIWhiteBalanceCalibrationMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIWhiteBalanceCalibrationMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TWhiteBalanceCalibrationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TWhiteBalanceCalibrationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TWhiteBalanceCalibrationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TWhiteBalanceCalibrationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TWhiteBalanceCalibrationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_read(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIWhiteBalanceCalibrationMode_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIWhiteBalanceCalibrationMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIWhiteBalanceCalibrationMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *,std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *,std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *,std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *,std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *,std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *,std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIWhiteBalanceCalibrationMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIWhiteBalanceCalibrationMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode> * const pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TWhiteBalanceCalibrationMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode> * const pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TWhiteBalanceCalibrationMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode> * const pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TWhiteBalanceCalibrationMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode> * const pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TWhiteBalanceCalibrationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TWhiteBalanceCalibrationMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceCalibrationMode_write(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIWhiteBalanceCalibrationMode_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIWhiteBalanceCalibrationMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIWhiteBalanceCalibrationMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIWhiteBalanceCalibrationMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; {
      { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIWhiteBalanceCalibrationMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIWhiteBalanceCalibrationMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIWhiteBalanceCalibrationMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIWhiteBalanceCalibrationMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *,mvIMPACT::acquire::TWhiteBalanceCalibrationMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *,mvIMPACT::acquire::TWhiteBalanceCalibrationMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *,std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *,std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *,std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const *,std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIWhiteBalanceParameter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIWhiteBalanceParameter",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIWhiteBalanceParameter__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIWhiteBalanceParameter__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIWhiteBalanceParameter'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIWhiteBalanceParameter_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIWhiteBalanceParameter_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIWhiteBalanceParameter_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIWhiteBalanceParameter_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIWhiteBalanceParameter_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIWhiteBalanceParameter_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIWhiteBalanceParameter_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TWhiteBalanceParameter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TWhiteBalanceParameter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIWhiteBalanceParameter_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIWhiteBalanceParameter_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIWhiteBalanceParameter_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIWhiteBalanceParameter_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIWhiteBalanceParameter_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIWhiteBalanceParameter_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceParameter> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TWhiteBalanceParameter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TWhiteBalanceParameter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TWhiteBalanceParameter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TWhiteBalanceParameter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TWhiteBalanceParameter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->read(*arg2,arg3,arg4); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceParameter> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->read(*arg2,arg3,arg4); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIWhiteBalanceParameter_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIWhiteBalanceParameter_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; {
      { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIWhiteBalanceParameter_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIWhiteBalanceParameter_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIWhiteBalanceParameter_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIWhiteBalanceParameter_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIWhiteBalanceParameter_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIWhiteBalanceParameter_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIWhiteBalanceParameter_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIWhiteBalanceParameter_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *,std::vector< mvIMPACT::acquire::TWhiteBalanceParameter > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *,std::vector< mvIMPACT::acquire::TWhiteBalanceParameter > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *,std::vector< mvIMPACT::acquire::TWhiteBalanceParameter > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *,std::vector< mvIMPACT::acquire::TWhiteBalanceParameter > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *,std::vector< mvIMPACT::acquire::TWhiteBalanceParameter > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *,std::vector< mvIMPACT::acquire::TWhiteBalanceParameter > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIWhiteBalanceParameter_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIWhiteBalanceParameter_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TWhiteBalanceParameter> * const pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceParameter> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TWhiteBalanceParameter>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TWhiteBalanceParameter,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TWhiteBalanceParameter > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TWhiteBalanceParameter> * const pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceParameter> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TWhiteBalanceParameter>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TWhiteBalanceParameter,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TWhiteBalanceParameter > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TWhiteBalanceParameter> * const pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceParameter> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TWhiteBalanceParameter>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TWhiteBalanceParameter,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TWhiteBalanceParameter > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TWhiteBalanceParameter> * const pV = new std::vector<mvIMPACT::acquire::TWhiteBalanceParameter> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TWhiteBalanceParameter>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TWhiteBalanceParameter,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TWhiteBalanceParameter > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TWhiteBalanceParameter_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIWhiteBalanceParameter_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIWhiteBalanceParameter_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIWhiteBalanceParameter_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIWhiteBalanceParameter_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIWhiteBalanceParameter_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIWhiteBalanceParameter_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIWhiteBalanceParameter_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIWhiteBalanceParameter_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIWhiteBalanceParameter_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *,mvIMPACT::acquire::TWhiteBalanceParameter,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *,mvIMPACT::acquire::TWhiteBalanceParameter)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *,std::vector< mvIMPACT::acquire::TWhiteBalanceParameter > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *,std::vector< mvIMPACT::acquire::TWhiteBalanceParameter > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *,std::vector< mvIMPACT::acquire::TWhiteBalanceParameter > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter > const *,std::vector< mvIMPACT::acquire::TWhiteBalanceParameter > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< int > *)new mvIMPACT::acquire::EnumPropertyI< int >(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< int > *)new mvIMPACT::acquire::EnumPropertyI< int >(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyI",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyI__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyI__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyI'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< int >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< int >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *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); {
    std::vector<std::pair< std::string, int> >* pV; if (!PyList_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    pV = new std::vector<std::pair< std::string, int> > (0); arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< int > *) &((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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; }  }  }  { if( arg2 ) { delete( arg2 ); }  }
   return resultobj; fail: { if( arg2 ) { delete( arg2 ); }  }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->getTranslationDictString(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->getTranslationDictString(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_getTranslationDictString(PyObject *self, PyObject *args) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyI_getTranslationDictString",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyI_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyI_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyI_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n" "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< int > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< int > const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->getTranslationDictValue(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->getTranslationDictValue(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_getTranslationDictValue(PyObject *self, PyObject *args) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyI_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyI_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyI_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyI_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n" "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< int > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< int > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyI_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyI_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< int > *) &((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyI_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< 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> * const pV = new std::vector<int> (0); arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< int > *) &((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 ); { }  {
    if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->read(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->read(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->getMaxValue(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->getMinValue(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->getStepWidth(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< 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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< 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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< 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> * const pV = new std::vector<int> (0); arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< 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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->read(*arg2,arg3,arg4,arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< 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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< 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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyI_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyI_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { { _v = PyList_Check(argv[1]);  } } 
    if (!_v) goto check_2; return _wrap_PropertyI_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyI_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyI_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyI_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyI_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyI_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyI_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyI_read'.\n"
  "  Possible C/C++ prototypes are:\n" "    read(mvIMPACT::acquire::EnumPropertyI< int > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< int > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< int > const *,std::vector< int > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< int > const *,std::vector< int > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< int > const *,std::vector< int > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< int > const *,std::vector< int > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< int > const *,std::vector< int > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< int > const *,std::vector< int > &,bool)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< int > *) &((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyI_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< int > *) &((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyI_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< 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 (!PySequence_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; }  const int size = PySequence_Length(swig_obj[1]);
    std::vector<int> * const pV = new std::vector<int> (size); for (int i = 0; i < size; i++) {
      PyObject * const o = PySequence_GetItem(swig_obj[1],i); std::vector<int>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_int,SWIG_POINTER_EXCEPTION) == -1) { SWIG_fail; }  (*pV)[i] = *pItem; 
      Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< int > *) &((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->write((std::vector< int > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 ); { }  {
    if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< 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 (!PySequence_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; }  const int size = PySequence_Length(swig_obj[1]);
    std::vector<int> * const pV = new std::vector<int> (size); for (int i = 0; i < size; i++) {
      PyObject * const o = PySequence_GetItem(swig_obj[1],i); std::vector<int>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_int,SWIG_POINTER_EXCEPTION) == -1) { SWIG_fail; }  (*pV)[i] = *pItem; 
      Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< int > *) &((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->write((std::vector< int > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 ); { }  {
    if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< 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 (!PySequence_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; }  const int size = PySequence_Length(swig_obj[1]);
    std::vector<int> * const pV = new std::vector<int> (size); for (int i = 0; i < size; i++) {
      PyObject * const o = PySequence_GetItem(swig_obj[1],i); std::vector<int>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_int,SWIG_POINTER_EXCEPTION) == -1) { SWIG_fail; }  (*pV)[i] = *pItem; 
      Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< int > *) &((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->write((std::vector< int > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 ); { }  {
    if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< int > *arg1 = (mvIMPACT::acquire::EnumPropertyI< int > *) 0 ;
  std::vector< 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 (!PySequence_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; }  const int size = PySequence_Length(swig_obj[1]);
    std::vector<int> * const pV = new std::vector<int> (size); for (int i = 0; i < size; i++) {
      PyObject * const o = PySequence_GetItem(swig_obj[1],i); std::vector<int>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_int,SWIG_POINTER_EXCEPTION) == -1) { SWIG_fail; }  (*pV)[i] = *pItem; 
      Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< int > *) &((mvIMPACT::acquire::EnumPropertyI< int > const *)arg1)->write((std::vector< int > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_int_t, 0 |  0 ); { }  {
    if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyI_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1; return _wrap_PropertyI_write__SWIG_3(self, argc, argv);} 
  check_1: if (argc == 2) { return _wrap_PropertyI_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; return _wrap_PropertyI_write__SWIG_2(self, argc, argv);} 
  check_3: if (argc == 3) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyI_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyI_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyI_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyI_write'.\n"
  "  Possible C/C++ prototypes are:\n" "    write(mvIMPACT::acquire::EnumPropertyI< int > const *,int,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< int > const *,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< int > const *,std::vector< int > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< int > const *,std::vector< int > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< int > const *,std::vector< int > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< int > const *,std::vector< int > const &,bool)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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_PropertyI64__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *)new mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyI64__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *)new mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyI64(PyObject *self, PyObject *args) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyI64",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyI64__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyI64__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyI64'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >()\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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,int64_t > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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_int64_t_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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_int64_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyI64_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,int64_t > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyI64_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,int64_t > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,int64_t > > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try {
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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_int64_t_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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_getTranslationDictString(PyObject *self, PyObject *args) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyI64_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyI64_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyI64_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyI64_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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 ; int64_t result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new int64_t(static_cast< const int64_t& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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 ; int64_t result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new int64_t(static_cast< const int64_t& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_getTranslationDictValue(PyObject *self, PyObject *args) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyI64_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyI64_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyI64_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyI64_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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_int64_t_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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyI64_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyI64_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: 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< int64_t > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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_int64_t_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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_int64_t_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyI64_getTranslationDictValues" "', argument " "2"" of type '" "std::vector< int64_t > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyI64_getTranslationDictValues" "', argument " "2"" of type '" "std::vector< int64_t > &""'"); }
   arg2 = reinterpret_cast< std::vector< int64_t > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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 ; int64_t result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->read(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new int64_t(static_cast< const int64_t& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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 ; int64_t result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->read(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new int64_t(static_cast< const int64_t& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  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] ; int64_t result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->getMaxValue(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new int64_t(static_cast< const int64_t& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  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] ; int64_t result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->getMinValue(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new int64_t(static_cast< const int64_t& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  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] ; int64_t result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->getStepWidth(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new int64_t(static_cast< const int64_t& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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< int64_t > *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__EnumPropertyI64T_int64_t_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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_int64_t_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyI64_read" "', argument " "2"" of type '" "std::vector< int64_t > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyI64_read" "', argument " "2"" of type '" "std::vector< int64_t > &""'"); }
   arg2 = reinterpret_cast< std::vector< int64_t > * >(argp2); 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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< int64_t > *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__EnumPropertyI64T_int64_t_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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_int64_t_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyI64_read" "', argument " "2"" of type '" "std::vector< int64_t > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyI64_read" "', argument " "2"" of type '" "std::vector< int64_t > &""'"); }
   arg2 = reinterpret_cast< std::vector< int64_t > * >(argp2); 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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< int64_t > *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__EnumPropertyI64T_int64_t_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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_int64_t_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyI64_read" "', argument " "2"" of type '" "std::vector< int64_t > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyI64_read" "', argument " "2"" of type '" "std::vector< int64_t > &""'"); }
   arg2 = reinterpret_cast< std::vector< int64_t > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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< int64_t > *arg2 = 0 ; bool arg3 ; int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ;
  int res2 = 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_int64_t_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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_int64_t_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyI64_read" "', argument " "2"" of type '" "std::vector< int64_t > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyI64_read" "', argument " "2"" of type '" "std::vector< int64_t > &""'"); }
   arg2 = reinterpret_cast< std::vector< int64_t > * >(argp2); 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->read(*arg2,arg3,arg4,arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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< int64_t > *arg2 = 0 ; bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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_int64_t_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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_int64_t_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyI64_read" "', argument " "2"" of type '" "std::vector< int64_t > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyI64_read" "', argument " "2"" of type '" "std::vector< int64_t > &""'"); }
   arg2 = reinterpret_cast< std::vector< int64_t > * >(argp2); 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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< int64_t > *arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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_int64_t_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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_int64_t_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyI64_read" "', argument " "2"" of type '" "std::vector< int64_t > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyI64_read" "', argument " "2"" of type '" "std::vector< int64_t > &""'"); }
   arg2 = reinterpret_cast< std::vector< int64_t > * >(argp2); 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyI64_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyI64_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_int64_t_t, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_2; return _wrap_PropertyI64_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyI64_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyI64_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyI64_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyI64_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyI64_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyI64_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyI64_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *,std::vector< int64_t > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *,std::vector< int64_t > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *,std::vector< int64_t > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *,std::vector< int64_t > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *,std::vector< int64_t > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *,std::vector< int64_t > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  int64_t arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 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_int64_t_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); {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t,  0  | 0); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyI64_write" "', argument " "2"" of type '" "int64_t""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyI64_write" "', argument " "2"" of type '" "int64_t""'"); }
     else { int64_t * temp = reinterpret_cast< int64_t * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; }  } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *arg1 = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) 0 ;
  int64_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 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_int64_t_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); {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t,  0  | 0); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyI64_write" "', argument " "2"" of type '" "int64_t""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyI64_write" "', argument " "2"" of type '" "int64_t""'"); }
     else { int64_t * temp = reinterpret_cast< int64_t * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; }  }  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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< int64_t > *arg2 = 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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_int64_t_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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_int64_t_t,  0  | 0); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyI64_write" "', argument " "2"" of type '" "std::vector< int64_t > const &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyI64_write" "', argument " "2"" of type '" "std::vector< int64_t > const &""'"); }
   arg2 = reinterpret_cast< std::vector< int64_t > * >(argp2); 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->write((std::vector< int64_t > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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< int64_t > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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_int64_t_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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_int64_t_t,  0  | 0); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyI64_write" "', argument " "2"" of type '" "std::vector< int64_t > const &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyI64_write" "', argument " "2"" of type '" "std::vector< int64_t > const &""'"); }
   arg2 = reinterpret_cast< std::vector< int64_t > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->write((std::vector< int64_t > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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< int64_t > *arg2 = 0 ; bool arg3 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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_int64_t_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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_int64_t_t,  0  | 0); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyI64_write" "', argument " "2"" of type '" "std::vector< int64_t > const &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyI64_write" "', argument " "2"" of type '" "std::vector< int64_t > const &""'"); }
   arg2 = reinterpret_cast< std::vector< int64_t > * >(argp2); 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->write((std::vector< int64_t > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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< int64_t > *arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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_int64_t_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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_int64_t_t,  0  | 0); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyI64_write" "', argument " "2"" of type '" "std::vector< int64_t > const &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyI64_write" "', argument " "2"" of type '" "std::vector< int64_t > const &""'"); }
   arg2 = reinterpret_cast< std::vector< int64_t > * >(argp2); 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *)arg1)->write((std::vector< int64_t > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyI64_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_int64_t, 0); _v = SWIG_CheckState(res);}  if (!_v) goto check_1;
    return _wrap_PropertyI64_write__SWIG_1(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyI64_write__SWIG_3(self, argc, argv);}  if (argc == 3) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_int64_t_t, 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_PropertyI64_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_int64_t, 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_PropertyI64_write__SWIG_0(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyI64_write__SWIG_5(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyI64_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyI64_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *,int64_t,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *,int64_t)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *,std::vector< int64_t > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *,std::vector< int64_t > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *,std::vector< int64_t > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > const *,std::vector< int64_t > const &,bool)\n");
  return NULL; }
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_int64_t_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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_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_PropertyI64DeviceTriggerOverlap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *)new mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *)new mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyI64DeviceTriggerOverlap",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyI64DeviceTriggerOverlap__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyI64DeviceTriggerOverlap__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyI64DeviceTriggerOverlap'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >()\n"
  "    mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyI64DeviceTriggerOverlap_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyI64DeviceTriggerOverlap_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyI64DeviceTriggerOverlap_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyI64DeviceTriggerOverlap_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyI64DeviceTriggerOverlap_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceTriggerOverlap)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceTriggerOverlap)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyI64DeviceTriggerOverlap_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyI64DeviceTriggerOverlap_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyI64DeviceTriggerOverlap_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyI64DeviceTriggerOverlap_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceTriggerOverlap)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceTriggerOverlap)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceTriggerOverlap)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceTriggerOverlap)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceTriggerOverlap)((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyI64DeviceTriggerOverlap_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; {
      { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyI64DeviceTriggerOverlap_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyI64DeviceTriggerOverlap_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyI64DeviceTriggerOverlap_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyI64DeviceTriggerOverlap_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap> * const pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceTriggerOverlap,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap> * const pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceTriggerOverlap,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap> * const pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceTriggerOverlap,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap> * const pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceTriggerOverlap>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceTriggerOverlap,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > *) &((mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_mvIMPACT__acquire__TDeviceTriggerOverlap_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyI64DeviceTriggerOverlap_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyI64DeviceTriggerOverlap_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyI64DeviceTriggerOverlap_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyI64DeviceTriggerOverlap_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyI64DeviceTriggerOverlap_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyI64DeviceTriggerOverlap_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyI64DeviceTriggerOverlap_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyI64DeviceTriggerOverlap_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyI64DeviceTriggerOverlap_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *,mvIMPACT::acquire::TDeviceTriggerOverlap,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *,mvIMPACT::acquire::TDeviceTriggerOverlap)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyPtr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyPtr *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { result = (mvIMPACT::acquire::PropertyPtr *)new mvIMPACT::acquire::PropertyPtr(); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::PropertyPtr *)new mvIMPACT::acquire::PropertyPtr(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyPtr",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyPtr__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyPtr__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyPtr'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::PropertyPtr()\n"
  "    mvIMPACT::acquire::PropertyPtr(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyPtr_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (void *)((mvIMPACT::acquire::PropertyPtr const *)arg1)->read(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyPtr_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (void *)((mvIMPACT::acquire::PropertyPtr const *)arg1)->read(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyPtr_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyPtr *arg1 = (mvIMPACT::acquire::PropertyPtr *) 0 ;
  std::vector< 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_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyPtr_read" "', argument " "2"" of type '" "std::vector< void * > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyPtr_read" "', argument " "2"" of type '" "std::vector< void * > &""'"); }
   arg2 = reinterpret_cast< std::vector< 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::PropertyPtr const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyPtr_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyPtr *arg1 = (mvIMPACT::acquire::PropertyPtr *) 0 ;
  std::vector< 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_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyPtr_read" "', argument " "2"" of type '" "std::vector< void * > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyPtr_read" "', argument " "2"" of type '" "std::vector< void * > &""'"); }
   arg2 = reinterpret_cast< std::vector< 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::PropertyPtr const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyPtr_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyPtr *arg1 = (mvIMPACT::acquire::PropertyPtr *) 0 ;
  std::vector< 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_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyPtr_read" "', argument " "2"" of type '" "std::vector< void * > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyPtr_read" "', argument " "2"" of type '" "std::vector< void * > &""'"); }
   arg2 = reinterpret_cast< std::vector< void * > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::PropertyPtr const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyPtr_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyPtr_read",0,4,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyPtr_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_void_p_t, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_2; return _wrap_PropertyPtr_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyPtr_read__SWIG_0(self, argc, argv);}  if (argc == 3) {
    return _wrap_PropertyPtr_read__SWIG_3(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyPtr_read__SWIG_2(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyPtr_read'.\n"
  "  Possible C/C++ prototypes are:\n" "    read(mvIMPACT::acquire::PropertyPtr const *,int)\n"
  "    read(mvIMPACT::acquire::PropertyPtr const *)\n"
  "    read(mvIMPACT::acquire::PropertyPtr const *,std::vector< void * > &,int,int)\n"
  "    read(mvIMPACT::acquire::PropertyPtr const *,std::vector< void * > &,int)\n"
  "    read(mvIMPACT::acquire::PropertyPtr const *,std::vector< void * > &)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyPtr_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::PropertyPtr *) &((mvIMPACT::acquire::PropertyPtr const *)arg1)->write(arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyPtr_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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 *""'");  } 
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::PropertyPtr *) &((mvIMPACT::acquire::PropertyPtr const *)arg1)->write(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyPtr_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyPtr *arg1 = (mvIMPACT::acquire::PropertyPtr *) 0 ;
  std::vector< 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_t,  0  | 0); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyPtr_write" "', argument " "2"" of type '" "std::vector< void * > const &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyPtr_write" "', argument " "2"" of type '" "std::vector< void * > const &""'"); }
   arg2 = reinterpret_cast< std::vector< 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::PropertyPtr *) &((mvIMPACT::acquire::PropertyPtr const *)arg1)->write((std::vector< void * > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyPtr_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyPtr *arg1 = (mvIMPACT::acquire::PropertyPtr *) 0 ;
  std::vector< 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_t,  0  | 0); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyPtr_write" "', argument " "2"" of type '" "std::vector< void * > const &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyPtr_write" "', argument " "2"" of type '" "std::vector< void * > const &""'"); }
   arg2 = reinterpret_cast< std::vector< void * > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::PropertyPtr *) &((mvIMPACT::acquire::PropertyPtr const *)arg1)->write((std::vector< void * > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyPtr_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[4];
  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_t, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_1; return _wrap_PropertyPtr_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyPtr_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_void_p_t, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_3; return _wrap_PropertyPtr_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) {
    return _wrap_PropertyPtr_write__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyPtr_write'.\n"
  "  Possible C/C++ prototypes are:\n" "    write(mvIMPACT::acquire::PropertyPtr const *,void *,int)\n"
  "    write(mvIMPACT::acquire::PropertyPtr const *,void *)\n"
  "    write(mvIMPACT::acquire::PropertyPtr const *,std::vector< void * > const &,int)\n"
  "    write(mvIMPACT::acquire::PropertyPtr const *,std::vector< void * > const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { result = (mvIMPACT::acquire::PropertyS *)new mvIMPACT::acquire::PropertyS(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::PropertyS *)new mvIMPACT::acquire::PropertyS(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyS",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyS__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyS__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyS'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::PropertyS()\n"
  "    mvIMPACT::acquire::PropertyS(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_binaryDataBufferSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::PropertyS const *)arg1)->binaryDataBufferSize(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::PropertyS const *)arg1)->binaryDataBufferSize(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyS_binaryDataBufferSize",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyS_binaryDataBufferSize__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyS_binaryDataBufferSize__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyS_binaryDataBufferSize'.\n"
  "  Possible C/C++ prototypes are:\n" "    binaryDataBufferSize(mvIMPACT::acquire::PropertyS const *,int)\n"
  "    binaryDataBufferSize(mvIMPACT::acquire::PropertyS const *)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::PropertyS const *)arg1)->binaryDataBufferMaxSize(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::PropertyS const *)arg1)->read(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::PropertyS const *)arg1)->read(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ;
  std::vector< std::string > *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__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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyS_read" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyS_read" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::PropertyS const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ;
  std::vector< std::string > *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__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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyS_read" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyS_read" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::PropertyS const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ;
  std::vector< std::string > *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__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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyS_read" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyS_read" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::PropertyS const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyS_read",0,4,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyS_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_std__string_t, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_2; return _wrap_PropertyS_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyS_read__SWIG_0(self, argc, argv);}  if (argc == 3) {
    return _wrap_PropertyS_read__SWIG_3(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyS_read__SWIG_2(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyS_read'.\n"
  "  Possible C/C++ prototypes are:\n" "    read(mvIMPACT::acquire::PropertyS const *,int)\n"
  "    read(mvIMPACT::acquire::PropertyS const *)\n"
  "    read(mvIMPACT::acquire::PropertyS const *,std::vector< std::string > &,int,int)\n"
  "    read(mvIMPACT::acquire::PropertyS const *,std::vector< std::string > &,int)\n"
  "    read(mvIMPACT::acquire::PropertyS const *,std::vector< std::string > &)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_readBinary__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::PropertyS const *)arg1)->readBinary(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::PropertyS const *)arg1)->readBinary(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_readBinary(PyObject *self, PyObject *args) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyS_readBinary",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyS_readBinary__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyS_readBinary__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyS_readBinary'.\n"
  "  Possible C/C++ prototypes are:\n" "    readBinary(mvIMPACT::acquire::PropertyS const *,int)\n"
  "    readBinary(mvIMPACT::acquire::PropertyS const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::PropertyS *) &((mvIMPACT::acquire::PropertyS const *)arg1)->write((std::string const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::PropertyS *) &((mvIMPACT::acquire::PropertyS const *)arg1)->write((std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ;
  std::vector< std::string > *arg2 = 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0  | 0); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyS_write" "', argument " "2"" of type '" "std::vector< std::string > const &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyS_write" "', argument " "2"" of type '" "std::vector< std::string > const &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::PropertyS *) &((mvIMPACT::acquire::PropertyS const *)arg1)->write((std::vector< std::string > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyS_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::PropertyS *arg1 = (mvIMPACT::acquire::PropertyS *) 0 ;
  std::vector< std::string > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0  | 0); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyS_write" "', argument " "2"" of type '" "std::vector< std::string > const &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyS_write" "', argument " "2"" of type '" "std::vector< std::string > const &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::PropertyS *) &((mvIMPACT::acquire::PropertyS const *)arg1)->write((std::vector< std::string > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyS_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyS_write",0,3,argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__string_t, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_1; return _wrap_PropertyS_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyS_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__string_t, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_3; return _wrap_PropertyS_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) {
    return _wrap_PropertyS_write__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyS_write'.\n"
  "  Possible C/C++ prototypes are:\n" "    write(mvIMPACT::acquire::PropertyS const *,std::string const &,int)\n"
  "    write(mvIMPACT::acquire::PropertyS const *,std::string const &)\n"
  "    write(mvIMPACT::acquire::PropertyS const *,std::vector< std::string > const &,int)\n"
  "    write(mvIMPACT::acquire::PropertyS const *,std::vector< std::string > const &)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyS_writeBinary__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::PropertyS *) &((mvIMPACT::acquire::PropertyS const *)arg1)->writeBinary((std::string const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::PropertyS *) &((mvIMPACT::acquire::PropertyS const *)arg1)->writeBinary((std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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(PyObject *self, PyObject *args) { int argc; PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyS_writeBinary",0,3,argv))) SWIG_fail; --argc; if (argc == 2) {
    return _wrap_PropertyS_writeBinary__SWIG_1(self, argc, argv);}  if (argc == 3) {
    return _wrap_PropertyS_writeBinary__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyS_writeBinary'.\n"
  "  Possible C/C++ prototypes are:\n" "    writeBinary(mvIMPACT::acquire::PropertyS const *,std::string const &,int)\n"
  "    writeBinary(mvIMPACT::acquire::PropertyS const *,std::string const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::UserDataEntry const *)arg1)->isValid(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (arg1)->createEntry(); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        (arg1)->deleteEntry(*arg2); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::UserData const *)arg1)->getFreeMemory(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::UserData const *)arg1)->getUserDataEntry(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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 > *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; } 
    std::vector<int> * const pV = new std::vector<int> (0); arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::UserData const *)arg1)->validUserDataEntryIndexes(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::UserData const *)arg1)->isAvailable(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::UserData const *)arg1)->writeToHardware(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Device *)new mvIMPACT::acquire::Device((mvIMPACT::acquire::Device const &)*arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { (arg1)->close(); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::Device const *)arg1)->hasCapability(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::HDEV)((mvIMPACT::acquire::Device const *)arg1)->hDev(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::HDRV)((mvIMPACT::acquire::Device const *)arg1)->hDrv(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Device const *)arg1)->deviceDriverFeatureList(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::Device const *)arg1)->isOpen(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Device_isInUse(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_isInUse" "', argument " "1"" of type '" "mvIMPACT::acquire::Device const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::Device const *)arg1)->isInUse(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { (arg1)->open(); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::Device const *)arg1)->setID(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::Device const *)arg1)->updateFirmware(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::UserData *) &(arg1)->getUserData(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::Device const *)arg1)->validateInterfaceLayout(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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 *Device_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args,(char*)"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), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceManager *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::DeviceManager *)new mvIMPACT::acquire::DeviceManager(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::DeviceManager *)new mvIMPACT::acquire::DeviceManager((mvIMPACT::acquire::DeviceManager const &)*arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_DeviceManager",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_DeviceManager__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_DeviceManager__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DeviceManager'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::DeviceManager()\n"
  "    mvIMPACT::acquire::DeviceManager(mvIMPACT::acquire::DeviceManager const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = mvIMPACT::acquire::DeviceManager::getVersionAsString(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::DeviceManager const *)arg1)->changedCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::DeviceManager const *)arg1)->deviceCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::DeviceManager const *)arg1)->updateDeviceList(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDevice(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceBySerial((std::string const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceBySerial((std::string const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceBySerial((std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceBySerial(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"DeviceManager_getDeviceBySerial",0,4,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_DeviceManager_getDeviceBySerial__SWIG_3(self, argc, argv);}  if (argc == 2) {
    return _wrap_DeviceManager_getDeviceBySerial__SWIG_2(self, argc, argv);}  if (argc == 3) {
    return _wrap_DeviceManager_getDeviceBySerial__SWIG_1(self, argc, argv);}  if (argc == 4) {
    return _wrap_DeviceManager_getDeviceBySerial__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'DeviceManager_getDeviceBySerial'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getDeviceBySerial(mvIMPACT::acquire::DeviceManager const *,std::string const &,unsigned int,char)\n"
  "    getDeviceBySerial(mvIMPACT::acquire::DeviceManager const *,std::string const &,unsigned int)\n"
  "    getDeviceBySerial(mvIMPACT::acquire::DeviceManager const *,std::string const &)\n"
  "    getDeviceBySerial(mvIMPACT::acquire::DeviceManager const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceByFamily__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByFamily((std::string const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByFamily((std::string const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByFamily((std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByFamily(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"DeviceManager_getDeviceByFamily",0,4,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_DeviceManager_getDeviceByFamily__SWIG_3(self, argc, argv);}  if (argc == 2) {
    return _wrap_DeviceManager_getDeviceByFamily__SWIG_2(self, argc, argv);}  if (argc == 3) {
    return _wrap_DeviceManager_getDeviceByFamily__SWIG_1(self, argc, argv);}  if (argc == 4) {
    return _wrap_DeviceManager_getDeviceByFamily__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'DeviceManager_getDeviceByFamily'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getDeviceByFamily(mvIMPACT::acquire::DeviceManager const *,std::string const &,unsigned int,char)\n"
  "    getDeviceByFamily(mvIMPACT::acquire::DeviceManager const *,std::string const &,unsigned int)\n"
  "    getDeviceByFamily(mvIMPACT::acquire::DeviceManager const *,std::string const &)\n"
  "    getDeviceByFamily(mvIMPACT::acquire::DeviceManager const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceByProduct__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByProduct((std::string const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByProduct((std::string const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByProduct((std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByProduct(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"DeviceManager_getDeviceByProduct",0,4,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_DeviceManager_getDeviceByProduct__SWIG_3(self, argc, argv);}  if (argc == 2) {
    return _wrap_DeviceManager_getDeviceByProduct__SWIG_2(self, argc, argv);}  if (argc == 3) {
    return _wrap_DeviceManager_getDeviceByProduct__SWIG_1(self, argc, argv);}  if (argc == 4) {
    return _wrap_DeviceManager_getDeviceByProduct__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'DeviceManager_getDeviceByProduct'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getDeviceByProduct(mvIMPACT::acquire::DeviceManager const *,std::string const &,unsigned int,char)\n"
  "    getDeviceByProduct(mvIMPACT::acquire::DeviceManager const *,std::string const &,unsigned int)\n"
  "    getDeviceByProduct(mvIMPACT::acquire::DeviceManager const *,std::string const &)\n"
  "    getDeviceByProduct(mvIMPACT::acquire::DeviceManager const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_DeviceManager_getDeviceByProductAndID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByProductAndID((std::string const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByProductAndID((std::string const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByProductAndID((std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByProductAndID(); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByProductAndID((std::string const &)*arg2,(std::string const &)*arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Device *)((mvIMPACT::acquire::DeviceManager const *)arg1)->getDeviceByProductAndID((std::string const &)*arg2,(std::string const &)*arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"DeviceManager_getDeviceByProductAndID",0,4,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_DeviceManager_getDeviceByProductAndID__SWIG_3(self, argc, argv);}  if (argc == 2) {
    return _wrap_DeviceManager_getDeviceByProductAndID__SWIG_2(self, argc, argv);}  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) {
    return _wrap_DeviceManager_getDeviceByProductAndID__SWIG_5(self, argc, argv);}  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;
    return _wrap_DeviceManager_getDeviceByProductAndID__SWIG_0(self, argc, argv);}  check_5: if (argc == 4) {
    return _wrap_DeviceManager_getDeviceByProductAndID__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'DeviceManager_getDeviceByProductAndID'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getDeviceByProductAndID(mvIMPACT::acquire::DeviceManager const *,std::string const &,unsigned int,char)\n"
  "    getDeviceByProductAndID(mvIMPACT::acquire::DeviceManager const *,std::string const &,unsigned int)\n"
  "    getDeviceByProductAndID(mvIMPACT::acquire::DeviceManager const *,std::string const &)\n"
  "    getDeviceByProductAndID(mvIMPACT::acquire::DeviceManager const *)\n"
  "    getDeviceByProductAndID(mvIMPACT::acquire::DeviceManager const *,std::string const &,std::string const &,char)\n"
  "    getDeviceByProductAndID(mvIMPACT::acquire::DeviceManager const *,std::string const &,std::string const &)\n");
  return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        mvIMPACT_acquire_DeviceManager_closeAllDevices(arg1); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Device *)mvIMPACT_acquire_DeviceManager___getitem__(arg1,arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::DeviceComponentLocator *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::DeviceComponentLocator *)new mvIMPACT::acquire::DeviceComponentLocator(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::DeviceComponentLocator *)new mvIMPACT::acquire::DeviceComponentLocator(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::DeviceComponentLocator *)new mvIMPACT::acquire::DeviceComponentLocator(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::DeviceComponentLocator *)new mvIMPACT::acquire::DeviceComponentLocator(arg1,arg2,(std::string const &)*arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::DeviceComponentLocator *)new mvIMPACT::acquire::DeviceComponentLocator(arg1,arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_DeviceComponentLocator",0,3,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_DeviceComponentLocator__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_DeviceComponentLocator__SWIG_1(self, argc, argv);}  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) {
    return _wrap_new_DeviceComponentLocator__SWIG_2(self, argc, argv);}  if (argc == 3) {
    return _wrap_new_DeviceComponentLocator__SWIG_3(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DeviceComponentLocator'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::DeviceComponentLocator()\n"
  "    mvIMPACT::acquire::DeviceComponentLocator(mvIMPACT::acquire::HLIST)\n"
  "    mvIMPACT::acquire::DeviceComponentLocator(mvIMPACT::acquire::HLIST,std::string const &)\n"
  "    mvIMPACT::acquire::DeviceComponentLocator(mvIMPACT::acquire::Device *,mvIMPACT::acquire::TDeviceListType,std::string const &)\n"
  "    mvIMPACT::acquire::DeviceComponentLocator(mvIMPACT::acquire::Device *,mvIMPACT::acquire::TDeviceListType)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_DeviceComponentLocator_bindSearchBaseList__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::HLIST)(arg1)->bindSearchBaseList(arg2,arg3,(std::string const &)*arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::HLIST)(arg1)->bindSearchBaseList(arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DeviceComponentLocator_bindSearchBaseList(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"DeviceComponentLocator_bindSearchBaseList",0,4,argv))) SWIG_fail; --argc;
  if (argc == 3) { return _wrap_DeviceComponentLocator_bindSearchBaseList__SWIG_1(self, argc, argv);}  if (argc == 4) {
    return _wrap_DeviceComponentLocator_bindSearchBaseList__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'DeviceComponentLocator_bindSearchBaseList'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    bindSearchBaseList(mvIMPACT::acquire::DeviceComponentLocator *,mvIMPACT::acquire::Device *,mvIMPACT::acquire::TDeviceListType,std::string const &)\n"
  "    bindSearchBaseList(mvIMPACT::acquire::DeviceComponentLocator *,mvIMPACT::acquire::Device *,mvIMPACT::acquire::TDeviceListType)\n");
  return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ImageBufferDesc *)new mvIMPACT::acquire::ImageBufferDesc((mvIMPACT::acquire::ImageBufferDesc const &)*arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ImageBufferDesc *)new mvIMPACT::acquire::ImageBufferDesc(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ImageBufferDesc *)new mvIMPACT::acquire::ImageBufferDesc(arg1,arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ImageBufferDesc *)new mvIMPACT::acquire::ImageBufferDesc((std::string const &)*arg1,arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ImageBufferDesc *)new mvIMPACT::acquire::ImageBufferDesc((std::string const &)*arg1); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[4];
  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, 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) {
    return _wrap_new_ImageBufferDesc__SWIG_4(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_ImageBufferDesc__SWIG_3(self, argc, argv);}  if (argc == 3) {
    return _wrap_new_ImageBufferDesc__SWIG_2(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ImageBufferDesc'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::ImageBufferDesc(mvIMPACT::acquire::ImageBufferDesc const &)\n"
  "    mvIMPACT::acquire::ImageBufferDesc(int)\n"
  "    mvIMPACT::acquire::ImageBufferDesc(mvIMPACT::acquire::TImageBufferPixelFormat,int,int)\n"
  "    mvIMPACT::acquire::ImageBufferDesc(std::string const &,mvIMPACT::acquire::TImageFileFormat)\n"
  "    mvIMPACT::acquire::ImageBufferDesc(std::string const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::ImageBufferDesc const *)arg1)->clone(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ImageBuffer *)((mvIMPACT::acquire::ImageBufferDesc const *)arg1)->getBuffer(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::ImageBufferDesc const *)arg1)->save((std::string const &)*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::ImageBufferDesc const *)arg1)->save((std::string const &)*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"ImageBufferDesc_save",0,3,argv))) SWIG_fail; --argc; if (argc == 2) {
    return _wrap_ImageBufferDesc_save__SWIG_1(self, argc, argv);}  if (argc == 3) {
    return _wrap_ImageBufferDesc_save__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ImageBufferDesc_save'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    save(mvIMPACT::acquire::ImageBufferDesc const *,std::string const &,mvIMPACT::acquire::TImageFileFormat)\n"
  "    save(mvIMPACT::acquire::ImageBufferDesc const *,std::string const &)\n"); return NULL; }
SWIGINTERN PyObject *ImageBufferDesc_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::HOBJ)((mvIMPACT::acquire::ComponentCollection const *)arg1)->hObj(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ComponentCollection *) &((mvIMPACT::acquire::ComponentCollection const *)arg1)->restoreDefault(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ImageBufferDesc *) &((mvIMPACT::acquire::BufferPart const *)arg1)->getImageBufferDesc(); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_int64_t_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__EnumPropertyIT_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Request *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::Request *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) 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 '" "new_Request" "', argument " "1"" of type '" "mvIMPACT::acquire::Request const &""'");  }
   if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Request" "', argument " "1"" of type '" "mvIMPACT::acquire::Request const &""'"); }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Request *)new mvIMPACT::acquire::Request((mvIMPACT::acquire::Request const &)*arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_Request",0,1,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_Request__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Request'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::Request(mvIMPACT::acquire::Request const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Request const *)arg1)->getComponentLocator(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::Request const *)arg1)->getBufferPartCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::BufferPart *) &((mvIMPACT::acquire::Request const *)arg1)->getBufferPart(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__BufferPart, 0 |  0 ); 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::Request const *)arg1)->getNumber(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ImageBufferDesc *) &((mvIMPACT::acquire::Request const *)arg1)->getImageBufferDesc(); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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::ComponentIterator 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Request const *)arg1)->getInfoIterator(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::ComponentIterator(static_cast< const mvIMPACT::acquire::ComponentIterator& >(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::ComponentIterator 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Request const *)arg1)->getImageProcessingResultsIterator(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::ComponentIterator(static_cast< const mvIMPACT::acquire::ComponentIterator& >(result))), SWIGTYPE_p_mvIMPACT__acquire__Component, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_hasProcessingBeenSkipped(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_hasProcessingBeenSkipped" "', argument " "1"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::Request const *)arg1)->hasProcessingBeenSkipped(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::Request const *)arg1)->getChunkCounterCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::Request const *)arg1)->getChunkTimerCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Request const *)arg1)->getChunkTimerValue(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::Request const *)arg1)->getChunkGainCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Request const *)arg1)->getChunkGain(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::Request const *)arg1)->getChunkGain((std::string const &)*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  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) {
    return _wrap_Request_getChunkGain__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Request_getChunkGain'.\n"
  "  Possible C/C++ prototypes are:\n" "    getChunkGain(mvIMPACT::acquire::Request const *,unsigned int)\n"
  "    getChunkGain(mvIMPACT::acquire::Request const *,std::string const &)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_Request_isOK(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_isOK" "', argument " "1"" of type '" "mvIMPACT::acquire::Request const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Request * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::Request const *)arg1)->isOK(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->configure(); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_Request_save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::Request const *)arg1)->save((std::string const &)*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::Request const *)arg1)->save((std::string const &)*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"Request_save",0,3,argv))) SWIG_fail; --argc; if (argc == 2) {
    return _wrap_Request_save__SWIG_1(self, argc, argv);}  if (argc == 3) { return _wrap_Request_save__SWIG_0(self, argc, argv);}
   fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Request_save'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    save(mvIMPACT::acquire::Request const *,std::string const &,mvIMPACT::acquire::TImageFileFormat)\n"
  "    save(mvIMPACT::acquire::Request const *,std::string const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->unlock(); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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 ; int res2 ; int val3 ; int ecode3 = 0 ; PyObject *swig_obj[3] ; int result;
  if (!SWIG_Python_UnpackTuple(args,"Request_attachUserBuffer",3,3,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);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Request_attachUserBuffer" "', 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 '" "Request_attachUserBuffer" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->attachUserBuffer(arg2,arg3); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->detachUserBuffer(); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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 *Request_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ImageRequestControl *)new mvIMPACT::acquire::ImageRequestControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ImageRequestControl *)new mvIMPACT::acquire::ImageRequestControl(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ImageRequestControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_ImageRequestControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_ImageRequestControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ImageRequestControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ImageRequestControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::ImageRequestControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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] ; 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Request *)(arg1)->createRequest(arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__Request, 0 |  0 ); return resultobj;
  fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_RequestFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::RequestFactory *result = 0 ; if (!SWIG_Python_UnpackTuple(args,"new_RequestFactory",0,0,0)) SWIG_fail; {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::RequestFactory *)new mvIMPACT::acquire::RequestFactory(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__RequestFactory, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *RequestFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args,(char*)"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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::FunctionInterface *)new mvIMPACT::acquire::FunctionInterface(arg1,arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::FunctionInterface *)new mvIMPACT::acquire::FunctionInterface(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::FunctionInterface *)new mvIMPACT::acquire::FunctionInterface((mvIMPACT::acquire::FunctionInterface const &)*arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  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) { return _wrap_new_FunctionInterface__SWIG_2(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_FunctionInterface__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FunctionInterface'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::FunctionInterface(mvIMPACT::acquire::Device *,mvIMPACT::acquire::RequestFactory *)\n"
  "    mvIMPACT::acquire::FunctionInterface(mvIMPACT::acquire::Device *)\n"
  "    mvIMPACT::acquire::FunctionInterface(mvIMPACT::acquire::FunctionInterface const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->acquisitionStart(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->acquisitionStop(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_createImageRequestControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->createImageRequestControl((std::string const &)*arg2,(std::string const &)*arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->createImageRequestControl((std::string const &)*arg2,(std::string const &)*arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->createImageRequestControl((std::string const &)*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"FunctionInterface_createImageRequestControl",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { return _wrap_FunctionInterface_createImageRequestControl__SWIG_2(self, argc, argv);}  if (argc == 3) {
    return _wrap_FunctionInterface_createImageRequestControl__SWIG_1(self, argc, argv);}  if (argc == 4) {
    return _wrap_FunctionInterface_createImageRequestControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FunctionInterface_createImageRequestControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    createImageRequestControl(mvIMPACT::acquire::FunctionInterface *,std::string const &,std::string const &,mvIMPACT::acquire::ComponentList *)\n"
  "    createImageRequestControl(mvIMPACT::acquire::FunctionInterface *,std::string const &,std::string const &)\n"
  "    createImageRequestControl(mvIMPACT::acquire::FunctionInterface *,std::string const &)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_createSetting__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->createSetting((std::string const &)*arg2,(std::string const &)*arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->createSetting((std::string const &)*arg2,(std::string const &)*arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { result = (int)(arg1)->createSetting((std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"FunctionInterface_createSetting",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    return _wrap_FunctionInterface_createSetting__SWIG_2(self, argc, argv);}  if (argc == 3) {
    return _wrap_FunctionInterface_createSetting__SWIG_1(self, argc, argv);}  if (argc == 4) {
    return _wrap_FunctionInterface_createSetting__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FunctionInterface_createSetting'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    createSetting(mvIMPACT::acquire::FunctionInterface *,std::string const &,std::string const &,mvIMPACT::acquire::ComponentList *)\n"
  "    createSetting(mvIMPACT::acquire::FunctionInterface *,std::string const &,std::string const &)\n"
  "    createSetting(mvIMPACT::acquire::FunctionInterface *,std::string const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->deleteSettingFromStack(); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_deleteSetting__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->deleteSetting((std::string const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->deleteSetting((std::string const &)*arg2,arg3); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->deleteSetting((std::string const &)*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"FunctionInterface_deleteSetting",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    return _wrap_FunctionInterface_deleteSetting__SWIG_2(self, argc, argv);}  if (argc == 3) {
    return _wrap_FunctionInterface_deleteSetting__SWIG_1(self, argc, argv);}  if (argc == 4) {
    return _wrap_FunctionInterface_deleteSetting__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FunctionInterface_deleteSetting'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    deleteSetting(mvIMPACT::acquire::FunctionInterface const *,std::string const &,mvIMPACT::acquire::TStorageLocation,mvIMPACT::acquire::TScope)\n"
  "    deleteSetting(mvIMPACT::acquire::FunctionInterface const *,std::string const &,mvIMPACT::acquire::TStorageLocation)\n"
  "    deleteSetting(mvIMPACT::acquire::FunctionInterface const *,std::string const &)\n"); return NULL; }
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 > *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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (std::vector< std::string > *) &((mvIMPACT::acquire::FunctionInterface const *)arg1)->getAvailableSettings(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; }  {
    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 > *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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (std::vector< std::string > *) &((mvIMPACT::acquire::FunctionInterface const *)arg1)->getAvailableImageRequestControls(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; }  {
    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] ; 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Request *)((mvIMPACT::acquire::FunctionInterface const *)arg1)->getRequest(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::FunctionInterface const *)arg1)->getSetting((std::string const &)*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->imageRequestConfigure((mvIMPACT::acquire::Request const *)arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_imageRequestResultQueueElementCount__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->imageRequestResultQueueElementCount(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_imageRequestResultQueueElementCount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->imageRequestResultQueueElementCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_imageRequestResultQueueElementCount(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"FunctionInterface_imageRequestResultQueueElementCount",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_FunctionInterface_imageRequestResultQueueElementCount__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_FunctionInterface_imageRequestResultQueueElementCount__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FunctionInterface_imageRequestResultQueueElementCount'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    imageRequestResultQueueElementCount(mvIMPACT::acquire::FunctionInterface const *,int)\n"
  "    imageRequestResultQueueElementCount(mvIMPACT::acquire::FunctionInterface const *)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->imageRequestReset(arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_imageRequestSingle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  mvIMPACT::acquire::ImageRequestControl *arg2 = (mvIMPACT::acquire::ImageRequestControl *) 0 ; int *arg3 = (int *) 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__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 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_imageRequestSingle" "', argument " "2"" of type '" "mvIMPACT::acquire::ImageRequestControl *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::ImageRequestControl * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 |  0 ); if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FunctionInterface_imageRequestSingle" "', argument " "3"" of type '" "int *""'");  }
   arg3 = reinterpret_cast< int * >(argp3); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->imageRequestSingle(arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_imageRequestSingle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  mvIMPACT::acquire::ImageRequestControl *arg2 = (mvIMPACT::acquire::ImageRequestControl *) 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 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionInterface_imageRequestSingle" "', argument " "2"" of type '" "mvIMPACT::acquire::ImageRequestControl *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::ImageRequestControl * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->imageRequestSingle(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_imageRequestSingle__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->imageRequestSingle(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_imageRequestSingle(PyObject *self, PyObject *args) { int argc; PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"FunctionInterface_imageRequestSingle",0,3,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_FunctionInterface_imageRequestSingle__SWIG_2(self, argc, argv);}  if (argc == 2) {
    return _wrap_FunctionInterface_imageRequestSingle__SWIG_1(self, argc, argv);}  if (argc == 3) {
    return _wrap_FunctionInterface_imageRequestSingle__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FunctionInterface_imageRequestSingle'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    imageRequestSingle(mvIMPACT::acquire::FunctionInterface const *,mvIMPACT::acquire::ImageRequestControl *,int *)\n"
  "    imageRequestSingle(mvIMPACT::acquire::FunctionInterface const *,mvIMPACT::acquire::ImageRequestControl *)\n"
  "    imageRequestSingle(mvIMPACT::acquire::FunctionInterface const *)\n"); 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->imageRequestUnlock(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_imageRequestWaitFor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->imageRequestWaitFor(arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_imageRequestWaitFor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->imageRequestWaitFor(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_imageRequestWaitFor(PyObject *self, PyObject *args) { int argc; PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"FunctionInterface_imageRequestWaitFor",0,3,argv))) SWIG_fail; --argc;
  if (argc == 2) { return _wrap_FunctionInterface_imageRequestWaitFor__SWIG_1(self, argc, argv);}  if (argc == 3) {
    return _wrap_FunctionInterface_imageRequestWaitFor__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FunctionInterface_imageRequestWaitFor'.\n"
  "  Possible C/C++ prototypes are:\n" "    imageRequestWaitFor(mvIMPACT::acquire::FunctionInterface const *,int,int)\n"
  "    imageRequestWaitFor(mvIMPACT::acquire::FunctionInterface const *,int)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_getCurrentCaptureBufferLayout__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  mvIMPACT::acquire::ImageRequestControl *arg2 = 0 ; mvIMPACT::acquire::Request **arg3 = (mvIMPACT::acquire::Request **) 0 ;
  int *arg4 = (int *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ;
  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_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);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FunctionInterface_getCurrentCaptureBufferLayout" "', argument " "3"" of type '" "mvIMPACT::acquire::Request **""'");  }
   arg3 = reinterpret_cast< mvIMPACT::acquire::Request ** >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 ); if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FunctionInterface_getCurrentCaptureBufferLayout" "', argument " "4"" of type '" "int *""'");  }
   arg4 = reinterpret_cast< int * >(argp4); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->getCurrentCaptureBufferLayout(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_getCurrentCaptureBufferLayout__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::FunctionInterface *arg1 = (mvIMPACT::acquire::FunctionInterface *) 0 ;
  mvIMPACT::acquire::ImageRequestControl *arg2 = 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__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);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_p_mvIMPACT__acquire__Request, 0 |  0 ); if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FunctionInterface_getCurrentCaptureBufferLayout" "', argument " "3"" of type '" "mvIMPACT::acquire::Request **""'");  }
   arg3 = reinterpret_cast< mvIMPACT::acquire::Request ** >(argp3); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->getCurrentCaptureBufferLayout(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_getCurrentCaptureBufferLayout__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->getCurrentCaptureBufferLayout(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_getCurrentCaptureBufferLayout__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  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 ; void *argp3 = 0 ; int res3 = 0 ; 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_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);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 ); if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FunctionInterface_getCurrentCaptureBufferLayout" "', argument " "3"" of type '" "int &""'");  }
   if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_getCurrentCaptureBufferLayout" "', argument " "3"" of type '" "int &""'"); }
   arg3 = reinterpret_cast< int * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FunctionInterface_getCurrentCaptureBufferLayout" "', argument " "4"" of type '" "int &""'");  }
   if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionInterface_getCurrentCaptureBufferLayout" "', argument " "4"" of type '" "int &""'"); }
   arg4 = reinterpret_cast< int * >(argp4); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->getCurrentCaptureBufferLayout(*arg2,*arg3,*arg4); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_getCurrentCaptureBufferLayout(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"FunctionInterface_getCurrentCaptureBufferLayout",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { return _wrap_FunctionInterface_getCurrentCaptureBufferLayout__SWIG_2(self, argc, argv);}  if (argc == 3) {
    return _wrap_FunctionInterface_getCurrentCaptureBufferLayout__SWIG_1(self, argc, argv);}  if (argc == 4) { int _v = 0; {
      void *vptr = 0; int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_p_mvIMPACT__acquire__Request, 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_3;
    return _wrap_FunctionInterface_getCurrentCaptureBufferLayout__SWIG_0(self, argc, argv);}  check_3: if (argc == 4) {
    return _wrap_FunctionInterface_getCurrentCaptureBufferLayout__SWIG_3(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FunctionInterface_getCurrentCaptureBufferLayout'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getCurrentCaptureBufferLayout(mvIMPACT::acquire::FunctionInterface const *,mvIMPACT::acquire::ImageRequestControl &,mvIMPACT::acquire::Request **,int *)\n"
  "    getCurrentCaptureBufferLayout(mvIMPACT::acquire::FunctionInterface const *,mvIMPACT::acquire::ImageRequestControl &,mvIMPACT::acquire::Request **)\n"
  "    getCurrentCaptureBufferLayout(mvIMPACT::acquire::FunctionInterface const *,mvIMPACT::acquire::ImageRequestControl &)\n"
  "    getCurrentCaptureBufferLayout(mvIMPACT::acquire::FunctionInterface const *,mvIMPACT::acquire::ImageRequestControl &,int &,int &)\n");
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::FunctionInterface const *)arg1)->isRequestNrValid(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_isSettingAvailable__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->isSettingAvailable((std::string const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->isSettingAvailable((std::string const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->isSettingAvailable((std::string const &)*arg2); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"FunctionInterface_isSettingAvailable",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { return _wrap_FunctionInterface_isSettingAvailable__SWIG_2(self, argc, argv);}  if (argc == 3) {
    return _wrap_FunctionInterface_isSettingAvailable__SWIG_1(self, argc, argv);}  if (argc == 4) {
    return _wrap_FunctionInterface_isSettingAvailable__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FunctionInterface_isSettingAvailable'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    isSettingAvailable(mvIMPACT::acquire::FunctionInterface const *,std::string const &,mvIMPACT::acquire::TStorageLocation,mvIMPACT::acquire::TScope)\n"
  "    isSettingAvailable(mvIMPACT::acquire::FunctionInterface const *,std::string const &,mvIMPACT::acquire::TStorageLocation)\n"
  "    isSettingAvailable(mvIMPACT::acquire::FunctionInterface const *,std::string const &)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_loadSetting__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->loadSetting((std::string const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->loadSetting((std::string const &)*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->loadSetting((std::string const &)*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"FunctionInterface_loadSetting",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    return _wrap_FunctionInterface_loadSetting__SWIG_2(self, argc, argv);}  if (argc == 3) {
    return _wrap_FunctionInterface_loadSetting__SWIG_1(self, argc, argv);}  if (argc == 4) {
    return _wrap_FunctionInterface_loadSetting__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FunctionInterface_loadSetting'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    loadSetting(mvIMPACT::acquire::FunctionInterface const *,std::string const &,mvIMPACT::acquire::TStorageFlag,mvIMPACT::acquire::TScope)\n"
  "    loadSetting(mvIMPACT::acquire::FunctionInterface const *,std::string const &,mvIMPACT::acquire::TStorageFlag)\n"
  "    loadSetting(mvIMPACT::acquire::FunctionInterface const *,std::string const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->loadSettingFromStack(); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->loadAndDeleteSettingFromStack(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_loadSettingFromDefault__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->loadSettingFromDefault(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_loadSettingFromDefault__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->loadSettingFromDefault(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_loadSettingFromDefault(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3]; if (!(argc = SWIG_Python_UnpackTuple(args,"FunctionInterface_loadSettingFromDefault",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_FunctionInterface_loadSettingFromDefault__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_FunctionInterface_loadSettingFromDefault__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FunctionInterface_loadSettingFromDefault'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    loadSettingFromDefault(mvIMPACT::acquire::FunctionInterface const *,mvIMPACT::acquire::TScope)\n"
  "    loadSettingFromDefault(mvIMPACT::acquire::FunctionInterface const *)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->requestCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->saveCurrentSettingOnStack(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_saveCurrentSettingOnStack__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->saveCurrentSettingOnStack(); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_saveCurrentSettingOnStack(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"FunctionInterface_saveCurrentSettingOnStack",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_FunctionInterface_saveCurrentSettingOnStack__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_FunctionInterface_saveCurrentSettingOnStack__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FunctionInterface_saveCurrentSettingOnStack'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    saveCurrentSettingOnStack(mvIMPACT::acquire::FunctionInterface *,mvIMPACT::acquire::TStorageFlag)\n"
  "    saveCurrentSettingOnStack(mvIMPACT::acquire::FunctionInterface *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_saveSetting__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->saveSetting((std::string const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->saveSetting((std::string const &)*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->saveSetting((std::string const &)*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"FunctionInterface_saveSetting",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    return _wrap_FunctionInterface_saveSetting__SWIG_2(self, argc, argv);}  if (argc == 3) {
    return _wrap_FunctionInterface_saveSetting__SWIG_1(self, argc, argv);}  if (argc == 4) {
    return _wrap_FunctionInterface_saveSetting__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FunctionInterface_saveSetting'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    saveSetting(mvIMPACT::acquire::FunctionInterface const *,std::string const &,mvIMPACT::acquire::TStorageFlag,mvIMPACT::acquire::TScope)\n"
  "    saveSetting(mvIMPACT::acquire::FunctionInterface const *,std::string const &,mvIMPACT::acquire::TStorageFlag)\n"
  "    saveSetting(mvIMPACT::acquire::FunctionInterface const *,std::string const &)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_saveSettingToDefault__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->saveSettingToDefault(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_saveSettingToDefault__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::FunctionInterface const *)arg1)->saveSettingToDefault(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FunctionInterface_saveSettingToDefault(PyObject *self, PyObject *args) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"FunctionInterface_saveSettingToDefault",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_FunctionInterface_saveSettingToDefault__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_FunctionInterface_saveSettingToDefault__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FunctionInterface_saveSettingToDefault'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    saveSettingToDefault(mvIMPACT::acquire::FunctionInterface const *,mvIMPACT::acquire::TScope)\n"
  "    saveSettingToDefault(mvIMPACT::acquire::FunctionInterface const *)\n"); return NULL; }
SWIGINTERN PyObject *FunctionInterface_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Info *)new mvIMPACT::acquire::Info(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::BasicDeviceSettings *)new mvIMPACT::acquire::BasicDeviceSettings(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::BasicDeviceSettings *)new mvIMPACT::acquire::BasicDeviceSettings(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_BasicDeviceSettings",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_BasicDeviceSettings__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_BasicDeviceSettings__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BasicDeviceSettings'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::BasicDeviceSettings(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::BasicDeviceSettings(mvIMPACT::acquire::Device *)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::TriggerControl const *)arg1)->getDescription(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::TriggerControl const *)arg1)->triggerSoftware(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ImageDestination *)new mvIMPACT::acquire::ImageDestination(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ImageDestination *)new mvIMPACT::acquire::ImageDestination(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ImageDestination",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_ImageDestination__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_ImageDestination__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ImageDestination'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ImageDestination(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::ImageDestination(mvIMPACT::acquire::Device *)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::RequestInfoConfiguration *)new mvIMPACT::acquire::RequestInfoConfiguration(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::RequestInfoConfiguration *)new mvIMPACT::acquire::RequestInfoConfiguration(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_RequestInfoConfiguration",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_RequestInfoConfiguration__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_RequestInfoConfiguration__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_RequestInfoConfiguration'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::RequestInfoConfiguration(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::RequestInfoConfiguration(mvIMPACT::acquire::Device *)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ImageProcessing *)new mvIMPACT::acquire::ImageProcessing(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ImageProcessing *)new mvIMPACT::acquire::ImageProcessing(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ImageProcessing *)new mvIMPACT::acquire::ImageProcessing((mvIMPACT::acquire::ImageProcessing const &)*arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  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) { return _wrap_new_ImageProcessing__SWIG_2(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_ImageProcessing__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ImageProcessing'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::ImageProcessing(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::ImageProcessing(mvIMPACT::acquire::Device *)\n"
  "    mvIMPACT::acquire::ImageProcessing(mvIMPACT::acquire::ImageProcessing const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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_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_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_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_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_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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { (arg1)->setSaturation(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GainOffsetKneeChannelParameters *) &((mvIMPACT::acquire::ImageProcessing const *)arg1)->getGainOffsetKneeParameter(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::ImageProcessing const *)arg1)->getGainOffsetKneeParameterCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::MirrorParameters *) &((mvIMPACT::acquire::ImageProcessing const *)arg1)->getMirrorParameter(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::ImageProcessing const *)arg1)->getMirrorParameterCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::LUTParameters *) &((mvIMPACT::acquire::ImageProcessing const *)arg1)->getLUTParameter(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::ImageProcessing const *)arg1)->getLUTParameterCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::WhiteBalanceSettings *) &((mvIMPACT::acquire::ImageProcessing const *)arg1)->getWBUserSetting(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::ImageProcessing const *)arg1)->getWBUserSettingsCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Statistics *)new mvIMPACT::acquire::Statistics(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::Statistics const *)arg1)->reset(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::FullSettingsBase *)new mvIMPACT::acquire::FullSettingsBase(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::FullSettingsBase *)new mvIMPACT::acquire::FullSettingsBase(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_FullSettingsBase",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_FullSettingsBase__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_FullSettingsBase__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FullSettingsBase'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::FullSettingsBase(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::FullSettingsBase(mvIMPACT::acquire::Device *)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::SystemSettings *)new mvIMPACT::acquire::SystemSettings(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_workerPriority_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::PropertyIThreadPriority *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_workerPriority_get" "', argument " "1"" of type '" "mvIMPACT::acquire::SystemSettings *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::SystemSettings * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyIThreadPriority *)& ((arg1)->workerPriority); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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_PropertyIAcquisitionField__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIAcquisitionField",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIAcquisitionField__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIAcquisitionField__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIAcquisitionField'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIAcquisitionField_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIAcquisitionField_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAcquisitionField_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAcquisitionField_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIAcquisitionField_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIAcquisitionField_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAcquisitionField_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAcquisitionField)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAcquisitionField)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAcquisitionField_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIAcquisitionField_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIAcquisitionField_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAcquisitionField_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIAcquisitionField_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIAcquisitionField_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TAcquisitionField> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAcquisitionField)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAcquisitionField)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAcquisitionField)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAcquisitionField)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAcquisitionField)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TAcquisitionField> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->read(*arg2,arg3,arg4,arg5); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAcquisitionField_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIAcquisitionField_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIAcquisitionField_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIAcquisitionField_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAcquisitionField_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIAcquisitionField_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIAcquisitionField_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIAcquisitionField_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIAcquisitionField_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAcquisitionField_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *,std::vector< mvIMPACT::acquire::TAcquisitionField > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *,std::vector< mvIMPACT::acquire::TAcquisitionField > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *,std::vector< mvIMPACT::acquire::TAcquisitionField > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *,std::vector< mvIMPACT::acquire::TAcquisitionField > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *,std::vector< mvIMPACT::acquire::TAcquisitionField > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *,std::vector< mvIMPACT::acquire::TAcquisitionField > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAcquisitionField_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAcquisitionField_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAcquisitionField> * const pV = new std::vector<mvIMPACT::acquire::TAcquisitionField> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAcquisitionField>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAcquisitionField,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionField > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAcquisitionField> * const pV = new std::vector<mvIMPACT::acquire::TAcquisitionField> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAcquisitionField>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAcquisitionField,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionField > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAcquisitionField> * const pV = new std::vector<mvIMPACT::acquire::TAcquisitionField> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAcquisitionField>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAcquisitionField,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionField > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAcquisitionField> * const pV = new std::vector<mvIMPACT::acquire::TAcquisitionField> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAcquisitionField>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAcquisitionField,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAcquisitionField > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAcquisitionField_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAcquisitionField_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAcquisitionField_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIAcquisitionField_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIAcquisitionField_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIAcquisitionField_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAcquisitionField_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIAcquisitionField_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIAcquisitionField_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAcquisitionField_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *,mvIMPACT::acquire::TAcquisitionField,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *,mvIMPACT::acquire::TAcquisitionField)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *,std::vector< mvIMPACT::acquire::TAcquisitionField > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *,std::vector< mvIMPACT::acquire::TAcquisitionField > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *,std::vector< mvIMPACT::acquire::TAcquisitionField > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField > const *,std::vector< mvIMPACT::acquire::TAcquisitionField > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIAutoControlSpeed__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIAutoControlSpeed",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIAutoControlSpeed__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIAutoControlSpeed__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIAutoControlSpeed'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIAutoControlSpeed_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIAutoControlSpeed_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAutoControlSpeed_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAutoControlSpeed_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIAutoControlSpeed_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIAutoControlSpeed_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAutoControlSpeed_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoControlSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoControlSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAutoControlSpeed_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIAutoControlSpeed_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIAutoControlSpeed_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAutoControlSpeed_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIAutoControlSpeed_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIAutoControlSpeed_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TAutoControlSpeed> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoControlSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoControlSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoControlSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoControlSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoControlSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TAutoControlSpeed> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->read(*arg2,arg3,arg4,arg5); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAutoControlSpeed_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIAutoControlSpeed_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIAutoControlSpeed_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIAutoControlSpeed_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAutoControlSpeed_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIAutoControlSpeed_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIAutoControlSpeed_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIAutoControlSpeed_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIAutoControlSpeed_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAutoControlSpeed_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *,std::vector< mvIMPACT::acquire::TAutoControlSpeed > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *,std::vector< mvIMPACT::acquire::TAutoControlSpeed > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *,std::vector< mvIMPACT::acquire::TAutoControlSpeed > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *,std::vector< mvIMPACT::acquire::TAutoControlSpeed > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *,std::vector< mvIMPACT::acquire::TAutoControlSpeed > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *,std::vector< mvIMPACT::acquire::TAutoControlSpeed > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAutoControlSpeed_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAutoControlSpeed_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAutoControlSpeed> * const pV = new std::vector<mvIMPACT::acquire::TAutoControlSpeed> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAutoControlSpeed>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAutoControlSpeed,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoControlSpeed > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAutoControlSpeed> * const pV = new std::vector<mvIMPACT::acquire::TAutoControlSpeed> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAutoControlSpeed>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAutoControlSpeed,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoControlSpeed > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAutoControlSpeed> * const pV = new std::vector<mvIMPACT::acquire::TAutoControlSpeed> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAutoControlSpeed>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAutoControlSpeed,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoControlSpeed > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAutoControlSpeed> * const pV = new std::vector<mvIMPACT::acquire::TAutoControlSpeed> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAutoControlSpeed>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAutoControlSpeed,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoControlSpeed > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlSpeed_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlSpeed_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAutoControlSpeed_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIAutoControlSpeed_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIAutoControlSpeed_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIAutoControlSpeed_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAutoControlSpeed_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIAutoControlSpeed_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIAutoControlSpeed_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAutoControlSpeed_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *,mvIMPACT::acquire::TAutoControlSpeed,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *,mvIMPACT::acquire::TAutoControlSpeed)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *,std::vector< mvIMPACT::acquire::TAutoControlSpeed > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *,std::vector< mvIMPACT::acquire::TAutoControlSpeed > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *,std::vector< mvIMPACT::acquire::TAutoControlSpeed > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed > const *,std::vector< mvIMPACT::acquire::TAutoControlSpeed > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIAutoControlMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIAutoControlMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIAutoControlMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIAutoControlMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIAutoControlMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIAutoControlMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIAutoControlMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAutoControlMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAutoControlMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIAutoControlMode_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIAutoControlMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAutoControlMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAutoControlMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIAutoControlMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIAutoControlMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAutoControlMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIAutoControlMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIAutoControlMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TAutoControlMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TAutoControlMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAutoControlMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIAutoControlMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIAutoControlMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIAutoControlMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAutoControlMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIAutoControlMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIAutoControlMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIAutoControlMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIAutoControlMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAutoControlMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *,std::vector< mvIMPACT::acquire::TAutoControlMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *,std::vector< mvIMPACT::acquire::TAutoControlMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *,std::vector< mvIMPACT::acquire::TAutoControlMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *,std::vector< mvIMPACT::acquire::TAutoControlMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *,std::vector< mvIMPACT::acquire::TAutoControlMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *,std::vector< mvIMPACT::acquire::TAutoControlMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAutoControlMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAutoControlMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAutoControlMode> * const pV = new std::vector<mvIMPACT::acquire::TAutoControlMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAutoControlMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAutoControlMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoControlMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAutoControlMode> * const pV = new std::vector<mvIMPACT::acquire::TAutoControlMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAutoControlMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAutoControlMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoControlMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAutoControlMode> * const pV = new std::vector<mvIMPACT::acquire::TAutoControlMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAutoControlMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAutoControlMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoControlMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAutoControlMode> * const pV = new std::vector<mvIMPACT::acquire::TAutoControlMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAutoControlMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAutoControlMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoControlMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoControlMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoControlMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAutoControlMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIAutoControlMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIAutoControlMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIAutoControlMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAutoControlMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIAutoControlMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIAutoControlMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAutoControlMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *,mvIMPACT::acquire::TAutoControlMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *,mvIMPACT::acquire::TAutoControlMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *,std::vector< mvIMPACT::acquire::TAutoControlMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *,std::vector< mvIMPACT::acquire::TAutoControlMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *,std::vector< mvIMPACT::acquire::TAutoControlMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode > const *,std::vector< mvIMPACT::acquire::TAutoControlMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIAutoExposureControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIAutoExposureControl",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIAutoExposureControl__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIAutoExposureControl__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIAutoExposureControl'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIAutoExposureControl_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIAutoExposureControl_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAutoExposureControl_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAutoExposureControl_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIAutoExposureControl_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIAutoExposureControl_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAutoExposureControl_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoExposureControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoExposureControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAutoExposureControl_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIAutoExposureControl_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIAutoExposureControl_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAutoExposureControl_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIAutoExposureControl_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIAutoExposureControl_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TAutoExposureControl> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoExposureControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoExposureControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoExposureControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoExposureControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoExposureControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TAutoExposureControl> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAutoExposureControl_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIAutoExposureControl_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIAutoExposureControl_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIAutoExposureControl_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAutoExposureControl_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIAutoExposureControl_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIAutoExposureControl_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIAutoExposureControl_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIAutoExposureControl_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAutoExposureControl_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *,std::vector< mvIMPACT::acquire::TAutoExposureControl > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *,std::vector< mvIMPACT::acquire::TAutoExposureControl > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *,std::vector< mvIMPACT::acquire::TAutoExposureControl > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *,std::vector< mvIMPACT::acquire::TAutoExposureControl > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *,std::vector< mvIMPACT::acquire::TAutoExposureControl > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *,std::vector< mvIMPACT::acquire::TAutoExposureControl > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAutoExposureControl_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAutoExposureControl_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAutoExposureControl> * const pV = new std::vector<mvIMPACT::acquire::TAutoExposureControl> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAutoExposureControl>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAutoExposureControl,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoExposureControl > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAutoExposureControl> * const pV = new std::vector<mvIMPACT::acquire::TAutoExposureControl> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAutoExposureControl>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAutoExposureControl,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoExposureControl > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAutoExposureControl> * const pV = new std::vector<mvIMPACT::acquire::TAutoExposureControl> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAutoExposureControl>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAutoExposureControl,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoExposureControl > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAutoExposureControl> * const pV = new std::vector<mvIMPACT::acquire::TAutoExposureControl> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAutoExposureControl>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAutoExposureControl,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoExposureControl > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoExposureControl_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAutoExposureControl_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIAutoExposureControl_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIAutoExposureControl_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIAutoExposureControl_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAutoExposureControl_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIAutoExposureControl_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIAutoExposureControl_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAutoExposureControl_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *,mvIMPACT::acquire::TAutoExposureControl,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *,mvIMPACT::acquire::TAutoExposureControl)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *,std::vector< mvIMPACT::acquire::TAutoExposureControl > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *,std::vector< mvIMPACT::acquire::TAutoExposureControl > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *,std::vector< mvIMPACT::acquire::TAutoExposureControl > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl > const *,std::vector< mvIMPACT::acquire::TAutoExposureControl > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIAutoGainControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIAutoGainControl",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIAutoGainControl__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIAutoGainControl__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIAutoGainControl'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIAutoGainControl_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIAutoGainControl_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAutoGainControl_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAutoGainControl_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIAutoGainControl_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIAutoGainControl_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAutoGainControl_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoGainControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoGainControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAutoGainControl_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIAutoGainControl_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIAutoGainControl_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAutoGainControl_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIAutoGainControl_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIAutoGainControl_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TAutoGainControl> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoGainControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoGainControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoGainControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoGainControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoGainControl)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TAutoGainControl> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->read(*arg2,arg3,arg4,arg5); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAutoGainControl_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIAutoGainControl_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIAutoGainControl_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIAutoGainControl_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAutoGainControl_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIAutoGainControl_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIAutoGainControl_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIAutoGainControl_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIAutoGainControl_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAutoGainControl_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *,std::vector< mvIMPACT::acquire::TAutoGainControl > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *,std::vector< mvIMPACT::acquire::TAutoGainControl > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *,std::vector< mvIMPACT::acquire::TAutoGainControl > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *,std::vector< mvIMPACT::acquire::TAutoGainControl > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *,std::vector< mvIMPACT::acquire::TAutoGainControl > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *,std::vector< mvIMPACT::acquire::TAutoGainControl > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAutoGainControl_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAutoGainControl_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAutoGainControl> * const pV = new std::vector<mvIMPACT::acquire::TAutoGainControl> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAutoGainControl>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAutoGainControl,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoGainControl > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAutoGainControl> * const pV = new std::vector<mvIMPACT::acquire::TAutoGainControl> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAutoGainControl>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAutoGainControl,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoGainControl > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAutoGainControl> * const pV = new std::vector<mvIMPACT::acquire::TAutoGainControl> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAutoGainControl>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAutoGainControl,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoGainControl > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAutoGainControl> * const pV = new std::vector<mvIMPACT::acquire::TAutoGainControl> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAutoGainControl>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAutoGainControl,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoGainControl > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoGainControl_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoGainControl_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAutoGainControl_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIAutoGainControl_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIAutoGainControl_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIAutoGainControl_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAutoGainControl_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIAutoGainControl_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIAutoGainControl_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAutoGainControl_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *,mvIMPACT::acquire::TAutoGainControl,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *,mvIMPACT::acquire::TAutoGainControl)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *,std::vector< mvIMPACT::acquire::TAutoGainControl > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *,std::vector< mvIMPACT::acquire::TAutoGainControl > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *,std::vector< mvIMPACT::acquire::TAutoGainControl > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl > const *,std::vector< mvIMPACT::acquire::TAutoGainControl > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIAutoOffsetCalibration__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIAutoOffsetCalibration",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIAutoOffsetCalibration__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIAutoOffsetCalibration__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIAutoOffsetCalibration'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIAutoOffsetCalibration_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIAutoOffsetCalibration_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAutoOffsetCalibration_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAutoOffsetCalibration_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIAutoOffsetCalibration_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIAutoOffsetCalibration_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAutoOffsetCalibration_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoOffsetCalibration)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoOffsetCalibration)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAutoOffsetCalibration_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIAutoOffsetCalibration_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIAutoOffsetCalibration_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAutoOffsetCalibration_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIAutoOffsetCalibration_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIAutoOffsetCalibration_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TAutoOffsetCalibration> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoOffsetCalibration)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoOffsetCalibration)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoOffsetCalibration)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoOffsetCalibration)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TAutoOffsetCalibration)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->read(*arg2,arg3,arg4); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TAutoOffsetCalibration> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->read(*arg2,arg3,arg4); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAutoOffsetCalibration_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIAutoOffsetCalibration_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; {
      { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIAutoOffsetCalibration_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIAutoOffsetCalibration_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAutoOffsetCalibration_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIAutoOffsetCalibration_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIAutoOffsetCalibration_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIAutoOffsetCalibration_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIAutoOffsetCalibration_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAutoOffsetCalibration_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *,std::vector< mvIMPACT::acquire::TAutoOffsetCalibration > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *,std::vector< mvIMPACT::acquire::TAutoOffsetCalibration > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *,std::vector< mvIMPACT::acquire::TAutoOffsetCalibration > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *,std::vector< mvIMPACT::acquire::TAutoOffsetCalibration > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *,std::vector< mvIMPACT::acquire::TAutoOffsetCalibration > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *,std::vector< mvIMPACT::acquire::TAutoOffsetCalibration > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAutoOffsetCalibration_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIAutoOffsetCalibration_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAutoOffsetCalibration> * const pV = new std::vector<mvIMPACT::acquire::TAutoOffsetCalibration> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAutoOffsetCalibration>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAutoOffsetCalibration,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoOffsetCalibration > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAutoOffsetCalibration> * const pV = new std::vector<mvIMPACT::acquire::TAutoOffsetCalibration> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAutoOffsetCalibration>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAutoOffsetCalibration,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoOffsetCalibration > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAutoOffsetCalibration> * const pV = new std::vector<mvIMPACT::acquire::TAutoOffsetCalibration> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAutoOffsetCalibration>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAutoOffsetCalibration,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoOffsetCalibration > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TAutoOffsetCalibration> * const pV = new std::vector<mvIMPACT::acquire::TAutoOffsetCalibration> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TAutoOffsetCalibration>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TAutoOffsetCalibration,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *)arg1)->write((std::vector< mvIMPACT::acquire::TAutoOffsetCalibration > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIAutoOffsetCalibration_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIAutoOffsetCalibration_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIAutoOffsetCalibration_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIAutoOffsetCalibration_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIAutoOffsetCalibration_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIAutoOffsetCalibration_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIAutoOffsetCalibration_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIAutoOffsetCalibration_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIAutoOffsetCalibration_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *,mvIMPACT::acquire::TAutoOffsetCalibration,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *,mvIMPACT::acquire::TAutoOffsetCalibration)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *,std::vector< mvIMPACT::acquire::TAutoOffsetCalibration > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *,std::vector< mvIMPACT::acquire::TAutoOffsetCalibration > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *,std::vector< mvIMPACT::acquire::TAutoOffsetCalibration > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration > const *,std::vector< mvIMPACT::acquire::TAutoOffsetCalibration > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIBlueFOXDigitalInputThreshold__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIBlueFOXDigitalInputThreshold",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyIBlueFOXDigitalInputThreshold__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIBlueFOXDigitalInputThreshold__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIBlueFOXDigitalInputThreshold'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIBlueFOXDigitalInputThreshold_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIBlueFOXDigitalInputThreshold_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > * >(argp2);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictString(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXDigitalInputThreshold_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) {
    return _wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXDigitalInputThreshold_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXDigitalInputThreshold)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXDigitalInputThreshold)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValue(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValue__SWIG_1(self, argc, argv);}
   if (argc == 2) { return _wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValue__SWIG_0(self, argc, argv);} 
  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIBlueFOXDigitalInputThreshold_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIBlueFOXDigitalInputThreshold_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXDigitalInputThreshold)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXDigitalInputThreshold)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXDigitalInputThreshold)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXDigitalInputThreshold)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXDigitalInputThreshold)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->read(*arg2); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_read(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXDigitalInputThreshold_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_1(self, argc, argv);}  if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIBlueFOXDigitalInputThreshold_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXDigitalInputThreshold_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *,std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *,std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *,std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *,std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *,std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *,std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXDigitalInputThreshold>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXDigitalInputThreshold_write(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXDigitalInputThreshold_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0;
    { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIBlueFOXDigitalInputThreshold_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXDigitalInputThreshold_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *,std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *,std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *,std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const *,std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIBlueFOXFooterMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIBlueFOXFooterMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIBlueFOXFooterMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIBlueFOXFooterMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIBlueFOXFooterMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIBlueFOXFooterMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIBlueFOXFooterMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBlueFOXFooterMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXFooterMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIBlueFOXFooterMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIBlueFOXFooterMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXFooterMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXFooterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXFooterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXFooterMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIBlueFOXFooterMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIBlueFOXFooterMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXFooterMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIBlueFOXFooterMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIBlueFOXFooterMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXFooterMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXFooterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXFooterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXFooterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXFooterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXFooterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXFooterMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXFooterMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIBlueFOXFooterMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIBlueFOXFooterMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIBlueFOXFooterMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBlueFOXFooterMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIBlueFOXFooterMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIBlueFOXFooterMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIBlueFOXFooterMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIBlueFOXFooterMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXFooterMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *,std::vector< mvIMPACT::acquire::TBlueFOXFooterMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *,std::vector< mvIMPACT::acquire::TBlueFOXFooterMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *,std::vector< mvIMPACT::acquire::TBlueFOXFooterMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *,std::vector< mvIMPACT::acquire::TBlueFOXFooterMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *,std::vector< mvIMPACT::acquire::TBlueFOXFooterMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *,std::vector< mvIMPACT::acquire::TBlueFOXFooterMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBlueFOXFooterMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBlueFOXFooterMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXFooterMode> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXFooterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXFooterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXFooterMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXFooterMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXFooterMode> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXFooterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXFooterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXFooterMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXFooterMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXFooterMode> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXFooterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXFooterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXFooterMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXFooterMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXFooterMode> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXFooterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXFooterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXFooterMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXFooterMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXFooterMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXFooterMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIBlueFOXFooterMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIBlueFOXFooterMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIBlueFOXFooterMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBlueFOXFooterMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIBlueFOXFooterMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIBlueFOXFooterMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXFooterMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *,mvIMPACT::acquire::TBlueFOXFooterMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *,mvIMPACT::acquire::TBlueFOXFooterMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *,std::vector< mvIMPACT::acquire::TBlueFOXFooterMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *,std::vector< mvIMPACT::acquire::TBlueFOXFooterMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *,std::vector< mvIMPACT::acquire::TBlueFOXFooterMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode > const *,std::vector< mvIMPACT::acquire::TBlueFOXFooterMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIBlueFOXInfoSensorCapabilities__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIBlueFOXInfoSensorCapabilities",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyIBlueFOXInfoSensorCapabilities__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIBlueFOXInfoSensorCapabilities__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIBlueFOXInfoSensorCapabilities'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIBlueFOXInfoSensorCapabilities_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > &""'"); }
  
  arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > * >(argp2);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictString(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) {
    return _wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValue(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) {
    return _wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->read(*arg2); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_read(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXInfoSensorCapabilities_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_1(self, argc, argv);}  if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIBlueFOXInfoSensorCapabilities_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXInfoSensorCapabilities_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *,std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *,std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *,std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *,std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *,std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *,std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXInfoSensorCapabilities_write(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXInfoSensorCapabilities_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0;
    { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIBlueFOXInfoSensorCapabilities_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXInfoSensorCapabilities_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *,std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *,std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *,std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const *,std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIBlueFOXOffsetAutoBlackSpeed__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[2]; if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIBlueFOXOffsetAutoBlackSpeed",0,1,argv))) SWIG_fail;
  --argc; if (argc == 0) { return _wrap_new_PropertyIBlueFOXOffsetAutoBlackSpeed__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIBlueFOXOffsetAutoBlackSpeed__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIBlueFOXOffsetAutoBlackSpeed'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > * >(argp2);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictString(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictString__SWIG_1(self, argc, argv);}
   if (argc == 2) { return _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictString__SWIG_0(self, argc, argv);} 
  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValue(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValue__SWIG_1(self, argc, argv);}
   if (argc == 2) { return _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXOffsetAutoBlackSpeed_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_1(self, argc, argv);}  if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXOffsetAutoBlackSpeed_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *,std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *,std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *,std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *,std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *,std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *,std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXOffsetAutoBlackSpeed_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; {
      { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXOffsetAutoBlackSpeed_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *,std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *,std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *,std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const *,std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIBlueFOXSensorTiming__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIBlueFOXSensorTiming",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIBlueFOXSensorTiming__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIBlueFOXSensorTiming__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIBlueFOXSensorTiming'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIBlueFOXSensorTiming_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIBlueFOXSensorTiming_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBlueFOXSensorTiming_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXSensorTiming_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIBlueFOXSensorTiming_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIBlueFOXSensorTiming_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXSensorTiming_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXSensorTiming)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXSensorTiming)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXSensorTiming_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIBlueFOXSensorTiming_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIBlueFOXSensorTiming_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXSensorTiming_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIBlueFOXSensorTiming_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIBlueFOXSensorTiming_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXSensorTiming)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXSensorTiming)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXSensorTiming)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXSensorTiming)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXSensorTiming)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXSensorTiming_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIBlueFOXSensorTiming_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIBlueFOXSensorTiming_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIBlueFOXSensorTiming_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBlueFOXSensorTiming_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIBlueFOXSensorTiming_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIBlueFOXSensorTiming_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIBlueFOXSensorTiming_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIBlueFOXSensorTiming_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXSensorTiming_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *,std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *,std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *,std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *,std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *,std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *,std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBlueFOXSensorTiming_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBlueFOXSensorTiming_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXSensorTiming,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXSensorTiming,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXSensorTiming,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXSensorTiming>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXSensorTiming,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXSensorTiming_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXSensorTiming_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXSensorTiming_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIBlueFOXSensorTiming_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIBlueFOXSensorTiming_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIBlueFOXSensorTiming_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBlueFOXSensorTiming_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIBlueFOXSensorTiming_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIBlueFOXSensorTiming_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXSensorTiming_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *,mvIMPACT::acquire::TBlueFOXSensorTiming,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *,mvIMPACT::acquire::TBlueFOXSensorTiming)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *,std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *,std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *,std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming > const *,std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIBlueFOXTransferSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIBlueFOXTransferSize",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIBlueFOXTransferSize__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIBlueFOXTransferSize__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIBlueFOXTransferSize'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIBlueFOXTransferSize_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIBlueFOXTransferSize_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBlueFOXTransferSize_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXTransferSize_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIBlueFOXTransferSize_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIBlueFOXTransferSize_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXTransferSize_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXTransferSize)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXTransferSize)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXTransferSize_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIBlueFOXTransferSize_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIBlueFOXTransferSize_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXTransferSize_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIBlueFOXTransferSize_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIBlueFOXTransferSize_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXTransferSize> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXTransferSize)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXTransferSize)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXTransferSize)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXTransferSize)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TBlueFOXTransferSize)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXTransferSize> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXTransferSize_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIBlueFOXTransferSize_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIBlueFOXTransferSize_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIBlueFOXTransferSize_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBlueFOXTransferSize_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIBlueFOXTransferSize_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIBlueFOXTransferSize_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIBlueFOXTransferSize_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIBlueFOXTransferSize_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXTransferSize_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *,std::vector< mvIMPACT::acquire::TBlueFOXTransferSize > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *,std::vector< mvIMPACT::acquire::TBlueFOXTransferSize > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *,std::vector< mvIMPACT::acquire::TBlueFOXTransferSize > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *,std::vector< mvIMPACT::acquire::TBlueFOXTransferSize > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *,std::vector< mvIMPACT::acquire::TBlueFOXTransferSize > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *,std::vector< mvIMPACT::acquire::TBlueFOXTransferSize > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBlueFOXTransferSize_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIBlueFOXTransferSize_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXTransferSize> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXTransferSize> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXTransferSize>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXTransferSize,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXTransferSize > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXTransferSize> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXTransferSize> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXTransferSize>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXTransferSize,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXTransferSize > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXTransferSize> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXTransferSize> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXTransferSize>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXTransferSize,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXTransferSize > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TBlueFOXTransferSize> * const pV = new std::vector<mvIMPACT::acquire::TBlueFOXTransferSize> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TBlueFOXTransferSize>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TBlueFOXTransferSize,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *)arg1)->write((std::vector< mvIMPACT::acquire::TBlueFOXTransferSize > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXTransferSize_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIBlueFOXTransferSize_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIBlueFOXTransferSize_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIBlueFOXTransferSize_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIBlueFOXTransferSize_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIBlueFOXTransferSize_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIBlueFOXTransferSize_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIBlueFOXTransferSize_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIBlueFOXTransferSize_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIBlueFOXTransferSize_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *,mvIMPACT::acquire::TBlueFOXTransferSize,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *,mvIMPACT::acquire::TBlueFOXTransferSize)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *,std::vector< mvIMPACT::acquire::TBlueFOXTransferSize > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *,std::vector< mvIMPACT::acquire::TBlueFOXTransferSize > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *,std::vector< mvIMPACT::acquire::TBlueFOXTransferSize > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize > const *,std::vector< mvIMPACT::acquire::TBlueFOXTransferSize > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyICameraAoiMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyICameraAoiMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyICameraAoiMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyICameraAoiMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyICameraAoiMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraAoiMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraAoiMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraAoiMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraAoiMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraAoiMode_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyICameraAoiMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraAoiMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraAoiMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraAoiMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyICameraAoiMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraAoiMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraAoiMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraAoiMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraAoiMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraAoiMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraAoiMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraAoiMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyICameraAoiMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraAoiMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyICameraAoiMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraAoiMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraAoiMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyICameraAoiMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyICameraAoiMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyICameraAoiMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraAoiMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *,std::vector< mvIMPACT::acquire::TCameraAoiMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *,std::vector< mvIMPACT::acquire::TCameraAoiMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *,std::vector< mvIMPACT::acquire::TCameraAoiMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *,std::vector< mvIMPACT::acquire::TCameraAoiMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *,std::vector< mvIMPACT::acquire::TCameraAoiMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *,std::vector< mvIMPACT::acquire::TCameraAoiMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraAoiMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraAoiMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraAoiMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraAoiMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraAoiMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraAoiMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraAoiMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraAoiMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraAoiMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraAoiMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraAoiMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraAoiMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraAoiMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraAoiMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraAoiMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraAoiMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraAoiMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraAoiMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraAoiMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraAoiMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraAoiMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraAoiMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraAoiMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraAoiMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraAoiMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraAoiMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyICameraAoiMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraAoiMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraAoiMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraAoiMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyICameraAoiMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraAoiMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *,mvIMPACT::acquire::TCameraAoiMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *,mvIMPACT::acquire::TCameraAoiMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *,std::vector< mvIMPACT::acquire::TCameraAoiMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *,std::vector< mvIMPACT::acquire::TCameraAoiMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *,std::vector< mvIMPACT::acquire::TCameraAoiMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode > const *,std::vector< mvIMPACT::acquire::TCameraAoiMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyICameraBinningMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyICameraBinningMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyICameraBinningMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyICameraBinningMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyICameraBinningMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraBinningMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraBinningMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraBinningMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraBinningMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraBinningMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyICameraBinningMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraBinningMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraBinningMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraBinningMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraBinningMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraBinningMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyICameraBinningMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraBinningMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraBinningMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraBinningMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraBinningMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraBinningMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraBinningMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraBinningMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraBinningMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraBinningMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraBinningMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraBinningMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyICameraBinningMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraBinningMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyICameraBinningMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraBinningMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraBinningMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyICameraBinningMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyICameraBinningMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyICameraBinningMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraBinningMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *,std::vector< mvIMPACT::acquire::TCameraBinningMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *,std::vector< mvIMPACT::acquire::TCameraBinningMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *,std::vector< mvIMPACT::acquire::TCameraBinningMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *,std::vector< mvIMPACT::acquire::TCameraBinningMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *,std::vector< mvIMPACT::acquire::TCameraBinningMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *,std::vector< mvIMPACT::acquire::TCameraBinningMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraBinningMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraBinningMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraBinningMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraBinningMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraBinningMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraBinningMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraBinningMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraBinningMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraBinningMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraBinningMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraBinningMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraBinningMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraBinningMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraBinningMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraBinningMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraBinningMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraBinningMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraBinningMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraBinningMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraBinningMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraBinningMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraBinningMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraBinningMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraBinningMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraBinningMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyICameraBinningMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraBinningMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraBinningMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraBinningMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyICameraBinningMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraBinningMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *,mvIMPACT::acquire::TCameraBinningMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *,mvIMPACT::acquire::TCameraBinningMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *,std::vector< mvIMPACT::acquire::TCameraBinningMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *,std::vector< mvIMPACT::acquire::TCameraBinningMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *,std::vector< mvIMPACT::acquire::TCameraBinningMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode > const *,std::vector< mvIMPACT::acquire::TCameraBinningMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyICameraDataFormat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyICameraDataFormat",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyICameraDataFormat__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyICameraDataFormat__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyICameraDataFormat'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraDataFormat_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraDataFormat_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraDataFormat_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraDataFormat_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraDataFormat_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyICameraDataFormat_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraDataFormat_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraDataFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraDataFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraDataFormat_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraDataFormat_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyICameraDataFormat_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraDataFormat_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraDataFormat_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraDataFormat_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraDataFormat> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraDataFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraDataFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraDataFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraDataFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraDataFormat)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraDataFormat> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->read(*arg2,arg3,arg4,arg5); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraDataFormat_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyICameraDataFormat_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraDataFormat_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyICameraDataFormat_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraDataFormat_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraDataFormat_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyICameraDataFormat_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyICameraDataFormat_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyICameraDataFormat_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraDataFormat_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *,std::vector< mvIMPACT::acquire::TCameraDataFormat > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *,std::vector< mvIMPACT::acquire::TCameraDataFormat > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *,std::vector< mvIMPACT::acquire::TCameraDataFormat > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *,std::vector< mvIMPACT::acquire::TCameraDataFormat > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *,std::vector< mvIMPACT::acquire::TCameraDataFormat > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *,std::vector< mvIMPACT::acquire::TCameraDataFormat > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraDataFormat_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraDataFormat_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraDataFormat> * const pV = new std::vector<mvIMPACT::acquire::TCameraDataFormat> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraDataFormat>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraDataFormat,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraDataFormat > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraDataFormat> * const pV = new std::vector<mvIMPACT::acquire::TCameraDataFormat> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraDataFormat>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraDataFormat,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraDataFormat > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraDataFormat> * const pV = new std::vector<mvIMPACT::acquire::TCameraDataFormat> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraDataFormat>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraDataFormat,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraDataFormat > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraDataFormat> * const pV = new std::vector<mvIMPACT::acquire::TCameraDataFormat> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraDataFormat>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraDataFormat,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraDataFormat > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraDataFormat_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraDataFormat_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraDataFormat_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraDataFormat_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyICameraDataFormat_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraDataFormat_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraDataFormat_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraDataFormat_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyICameraDataFormat_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraDataFormat_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *,mvIMPACT::acquire::TCameraDataFormat,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *,mvIMPACT::acquire::TCameraDataFormat)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *,std::vector< mvIMPACT::acquire::TCameraDataFormat > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *,std::vector< mvIMPACT::acquire::TCameraDataFormat > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *,std::vector< mvIMPACT::acquire::TCameraDataFormat > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat > const *,std::vector< mvIMPACT::acquire::TCameraDataFormat > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyICameraExposeMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyICameraExposeMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyICameraExposeMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyICameraExposeMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyICameraExposeMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraExposeMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraExposeMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraExposeMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraExposeMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraExposeMode_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyICameraExposeMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraExposeMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraExposeMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraExposeMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraExposeMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraExposeMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyICameraExposeMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraExposeMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraExposeMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraExposeMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraExposeMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraExposeMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraExposeMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraExposeMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraExposeMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraExposeMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraExposeMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraExposeMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyICameraExposeMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraExposeMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyICameraExposeMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraExposeMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraExposeMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyICameraExposeMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyICameraExposeMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyICameraExposeMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraExposeMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *,std::vector< mvIMPACT::acquire::TCameraExposeMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *,std::vector< mvIMPACT::acquire::TCameraExposeMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *,std::vector< mvIMPACT::acquire::TCameraExposeMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *,std::vector< mvIMPACT::acquire::TCameraExposeMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *,std::vector< mvIMPACT::acquire::TCameraExposeMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *,std::vector< mvIMPACT::acquire::TCameraExposeMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraExposeMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraExposeMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraExposeMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraExposeMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraExposeMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraExposeMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExposeMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraExposeMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraExposeMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraExposeMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraExposeMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExposeMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraExposeMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraExposeMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraExposeMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraExposeMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExposeMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraExposeMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraExposeMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraExposeMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraExposeMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExposeMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExposeMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraExposeMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraExposeMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyICameraExposeMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraExposeMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraExposeMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraExposeMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyICameraExposeMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraExposeMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *,mvIMPACT::acquire::TCameraExposeMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *,mvIMPACT::acquire::TCameraExposeMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *,std::vector< mvIMPACT::acquire::TCameraExposeMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *,std::vector< mvIMPACT::acquire::TCameraExposeMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *,std::vector< mvIMPACT::acquire::TCameraExposeMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode > const *,std::vector< mvIMPACT::acquire::TCameraExposeMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyICameraExternalSyncEdge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyICameraExternalSyncEdge",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyICameraExternalSyncEdge__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyICameraExternalSyncEdge__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyICameraExternalSyncEdge'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraExternalSyncEdge_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraExternalSyncEdge_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraExternalSyncEdge_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraExternalSyncEdge_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyICameraExternalSyncEdge_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyICameraExternalSyncEdge_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraExternalSyncEdge_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraExternalSyncEdge)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraExternalSyncEdge)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraExternalSyncEdge_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyICameraExternalSyncEdge_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyICameraExternalSyncEdge_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraExternalSyncEdge_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraExternalSyncEdge_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraExternalSyncEdge_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraExternalSyncEdge)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraExternalSyncEdge)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraExternalSyncEdge)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraExternalSyncEdge)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraExternalSyncEdge)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraExternalSyncEdge_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraExternalSyncEdge_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; {
      { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraExternalSyncEdge_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyICameraExternalSyncEdge_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraExternalSyncEdge_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraExternalSyncEdge_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyICameraExternalSyncEdge_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyICameraExternalSyncEdge_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyICameraExternalSyncEdge_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraExternalSyncEdge_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *,std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *,std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *,std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *,std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *,std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *,std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraExternalSyncEdge_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraExternalSyncEdge_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge> * const pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraExternalSyncEdge,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge> * const pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraExternalSyncEdge,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge> * const pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraExternalSyncEdge,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge> * const pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraExternalSyncEdge>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraExternalSyncEdge,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncEdge_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncEdge_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraExternalSyncEdge_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraExternalSyncEdge_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyICameraExternalSyncEdge_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraExternalSyncEdge_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraExternalSyncEdge_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraExternalSyncEdge_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyICameraExternalSyncEdge_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraExternalSyncEdge_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *,mvIMPACT::acquire::TCameraExternalSyncEdge,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *,mvIMPACT::acquire::TCameraExternalSyncEdge)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *,std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *,std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *,std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge > const *,std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyICameraExternalSyncOutput__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyICameraExternalSyncOutput",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyICameraExternalSyncOutput__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyICameraExternalSyncOutput__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyICameraExternalSyncOutput'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraExternalSyncOutput_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraExternalSyncOutput_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraExternalSyncOutput_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_getTranslationDictString(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraExternalSyncOutput_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyICameraExternalSyncOutput_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyICameraExternalSyncOutput_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraExternalSyncOutput_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraExternalSyncOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraExternalSyncOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraExternalSyncOutput_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyICameraExternalSyncOutput_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyICameraExternalSyncOutput_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraExternalSyncOutput_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraExternalSyncOutput_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraExternalSyncOutput_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraExternalSyncOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraExternalSyncOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraExternalSyncOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraExternalSyncOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraExternalSyncOutput)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->read(*arg2,arg3); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->read(*arg2,arg3); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraExternalSyncOutput_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraExternalSyncOutput_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0;
    { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraExternalSyncOutput_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyICameraExternalSyncOutput_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraExternalSyncOutput_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraExternalSyncOutput_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyICameraExternalSyncOutput_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyICameraExternalSyncOutput_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyICameraExternalSyncOutput_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraExternalSyncOutput_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *,std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *,std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *,std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *,std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *,std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *,std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraExternalSyncOutput_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraExternalSyncOutput_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput> * const pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraExternalSyncOutput,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput> * const pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraExternalSyncOutput,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput> * const pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraExternalSyncOutput,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput> * const pV = new std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraExternalSyncOutput>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraExternalSyncOutput,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraExternalSyncOutput_write(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5]; if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraExternalSyncOutput_write",0,4,argv))) SWIG_fail;
  --argc; if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraExternalSyncOutput_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyICameraExternalSyncOutput_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraExternalSyncOutput_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraExternalSyncOutput_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraExternalSyncOutput_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyICameraExternalSyncOutput_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraExternalSyncOutput_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *,mvIMPACT::acquire::TCameraExternalSyncOutput,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *,mvIMPACT::acquire::TCameraExternalSyncOutput)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *,std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *,std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *,std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput > const *,std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyICameraFlashMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyICameraFlashMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyICameraFlashMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyICameraFlashMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyICameraFlashMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraFlashMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraFlashMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraFlashMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraFlashMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraFlashMode_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyICameraFlashMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraFlashMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraFlashMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraFlashMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraFlashMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraFlashMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyICameraFlashMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraFlashMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraFlashMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraFlashMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraFlashMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraFlashMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraFlashMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraFlashMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraFlashMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraFlashMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraFlashMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraFlashMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyICameraFlashMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraFlashMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyICameraFlashMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraFlashMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraFlashMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyICameraFlashMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyICameraFlashMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyICameraFlashMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraFlashMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *,std::vector< mvIMPACT::acquire::TCameraFlashMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *,std::vector< mvIMPACT::acquire::TCameraFlashMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *,std::vector< mvIMPACT::acquire::TCameraFlashMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *,std::vector< mvIMPACT::acquire::TCameraFlashMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *,std::vector< mvIMPACT::acquire::TCameraFlashMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *,std::vector< mvIMPACT::acquire::TCameraFlashMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraFlashMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraFlashMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraFlashMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraFlashMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraFlashMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraFlashMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraFlashMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraFlashMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraFlashMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraFlashMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraFlashMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraFlashMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraFlashMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraFlashMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraFlashMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraFlashMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraFlashMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraFlashMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraFlashMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraFlashMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraFlashMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraFlashMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraFlashMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraFlashMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyICameraFlashMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraFlashMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraFlashMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraFlashMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyICameraFlashMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraFlashMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *,mvIMPACT::acquire::TCameraFlashMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *,mvIMPACT::acquire::TCameraFlashMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *,std::vector< mvIMPACT::acquire::TCameraFlashMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *,std::vector< mvIMPACT::acquire::TCameraFlashMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *,std::vector< mvIMPACT::acquire::TCameraFlashMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode > const *,std::vector< mvIMPACT::acquire::TCameraFlashMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyICameraFlashType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyICameraFlashType",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyICameraFlashType__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyICameraFlashType__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyICameraFlashType'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraFlashType_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraFlashType_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraFlashType_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraFlashType_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraFlashType_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyICameraFlashType_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraFlashType_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraFlashType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraFlashType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraFlashType_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraFlashType_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyICameraFlashType_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraFlashType_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraFlashType_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraFlashType_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraFlashType> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraFlashType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraFlashType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraFlashType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraFlashType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraFlashType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraFlashType> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->read(*arg2,arg3,arg4,arg5); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraFlashType_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyICameraFlashType_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraFlashType_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyICameraFlashType_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraFlashType_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraFlashType_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyICameraFlashType_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyICameraFlashType_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyICameraFlashType_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraFlashType_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *,std::vector< mvIMPACT::acquire::TCameraFlashType > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *,std::vector< mvIMPACT::acquire::TCameraFlashType > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *,std::vector< mvIMPACT::acquire::TCameraFlashType > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *,std::vector< mvIMPACT::acquire::TCameraFlashType > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *,std::vector< mvIMPACT::acquire::TCameraFlashType > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *,std::vector< mvIMPACT::acquire::TCameraFlashType > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraFlashType_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraFlashType_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraFlashType> * const pV = new std::vector<mvIMPACT::acquire::TCameraFlashType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraFlashType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraFlashType,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraFlashType > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraFlashType> * const pV = new std::vector<mvIMPACT::acquire::TCameraFlashType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraFlashType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraFlashType,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraFlashType > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraFlashType> * const pV = new std::vector<mvIMPACT::acquire::TCameraFlashType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraFlashType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraFlashType,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraFlashType > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraFlashType> * const pV = new std::vector<mvIMPACT::acquire::TCameraFlashType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraFlashType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraFlashType,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraFlashType > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraFlashType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraFlashType_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraFlashType_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraFlashType_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyICameraFlashType_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraFlashType_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraFlashType_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraFlashType_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyICameraFlashType_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraFlashType_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *,mvIMPACT::acquire::TCameraFlashType,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *,mvIMPACT::acquire::TCameraFlashType)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *,std::vector< mvIMPACT::acquire::TCameraFlashType > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *,std::vector< mvIMPACT::acquire::TCameraFlashType > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *,std::vector< mvIMPACT::acquire::TCameraFlashType > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType > const *,std::vector< mvIMPACT::acquire::TCameraFlashType > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyICameraHDRMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyICameraHDRMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyICameraHDRMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyICameraHDRMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyICameraHDRMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraHDRMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraHDRMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraHDRMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraHDRMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraHDRMode_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyICameraHDRMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraHDRMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraHDRMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraHDRMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraHDRMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraHDRMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyICameraHDRMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraHDRMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraHDRMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraHDRMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraHDRMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraHDRMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraHDRMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraHDRMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraHDRMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraHDRMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraHDRMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraHDRMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyICameraHDRMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraHDRMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyICameraHDRMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraHDRMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraHDRMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyICameraHDRMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyICameraHDRMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyICameraHDRMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraHDRMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *,std::vector< mvIMPACT::acquire::TCameraHDRMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *,std::vector< mvIMPACT::acquire::TCameraHDRMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *,std::vector< mvIMPACT::acquire::TCameraHDRMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *,std::vector< mvIMPACT::acquire::TCameraHDRMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *,std::vector< mvIMPACT::acquire::TCameraHDRMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *,std::vector< mvIMPACT::acquire::TCameraHDRMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraHDRMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraHDRMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraHDRMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraHDRMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraHDRMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraHDRMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraHDRMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraHDRMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraHDRMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraHDRMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraHDRMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraHDRMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraHDRMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraHDRMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraHDRMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraHDRMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraHDRMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraHDRMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraHDRMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraHDRMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraHDRMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraHDRMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraHDRMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraHDRMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraHDRMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraHDRMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyICameraHDRMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraHDRMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraHDRMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraHDRMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyICameraHDRMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraHDRMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *,mvIMPACT::acquire::TCameraHDRMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *,mvIMPACT::acquire::TCameraHDRMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *,std::vector< mvIMPACT::acquire::TCameraHDRMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *,std::vector< mvIMPACT::acquire::TCameraHDRMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *,std::vector< mvIMPACT::acquire::TCameraHDRMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode > const *,std::vector< mvIMPACT::acquire::TCameraHDRMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyICameraInterlacedType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyICameraInterlacedType",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyICameraInterlacedType__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyICameraInterlacedType__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyICameraInterlacedType'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraInterlacedType_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraInterlacedType_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraInterlacedType_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraInterlacedType_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyICameraInterlacedType_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyICameraInterlacedType_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraInterlacedType_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraInterlacedType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraInterlacedType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraInterlacedType_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyICameraInterlacedType_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyICameraInterlacedType_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraInterlacedType_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraInterlacedType_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraInterlacedType_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraInterlacedType> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraInterlacedType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraInterlacedType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraInterlacedType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraInterlacedType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraInterlacedType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->read(*arg2,arg3,arg4); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraInterlacedType> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->read(*arg2,arg3,arg4); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraInterlacedType_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyICameraInterlacedType_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraInterlacedType_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyICameraInterlacedType_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraInterlacedType_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraInterlacedType_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyICameraInterlacedType_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyICameraInterlacedType_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyICameraInterlacedType_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraInterlacedType_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *,std::vector< mvIMPACT::acquire::TCameraInterlacedType > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *,std::vector< mvIMPACT::acquire::TCameraInterlacedType > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *,std::vector< mvIMPACT::acquire::TCameraInterlacedType > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *,std::vector< mvIMPACT::acquire::TCameraInterlacedType > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *,std::vector< mvIMPACT::acquire::TCameraInterlacedType > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *,std::vector< mvIMPACT::acquire::TCameraInterlacedType > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraInterlacedType_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraInterlacedType_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraInterlacedType> * const pV = new std::vector<mvIMPACT::acquire::TCameraInterlacedType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraInterlacedType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraInterlacedType,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraInterlacedType > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraInterlacedType> * const pV = new std::vector<mvIMPACT::acquire::TCameraInterlacedType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraInterlacedType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraInterlacedType,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraInterlacedType > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraInterlacedType> * const pV = new std::vector<mvIMPACT::acquire::TCameraInterlacedType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraInterlacedType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraInterlacedType,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraInterlacedType > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraInterlacedType> * const pV = new std::vector<mvIMPACT::acquire::TCameraInterlacedType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraInterlacedType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraInterlacedType,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraInterlacedType > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraInterlacedType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraInterlacedType_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraInterlacedType_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraInterlacedType_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyICameraInterlacedType_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraInterlacedType_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraInterlacedType_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraInterlacedType_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyICameraInterlacedType_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraInterlacedType_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *,mvIMPACT::acquire::TCameraInterlacedType,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *,mvIMPACT::acquire::TCameraInterlacedType)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *,std::vector< mvIMPACT::acquire::TCameraInterlacedType > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *,std::vector< mvIMPACT::acquire::TCameraInterlacedType > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *,std::vector< mvIMPACT::acquire::TCameraInterlacedType > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType > const *,std::vector< mvIMPACT::acquire::TCameraInterlacedType > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyICameraLinkDataValidMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyICameraLinkDataValidMode",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyICameraLinkDataValidMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyICameraLinkDataValidMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyICameraLinkDataValidMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraLinkDataValidMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraLinkDataValidMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraLinkDataValidMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraLinkDataValidMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyICameraLinkDataValidMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyICameraLinkDataValidMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraLinkDataValidMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraLinkDataValidMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraLinkDataValidMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraLinkDataValidMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyICameraLinkDataValidMode_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyICameraLinkDataValidMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraLinkDataValidMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraLinkDataValidMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraLinkDataValidMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraLinkDataValidMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraLinkDataValidMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraLinkDataValidMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraLinkDataValidMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraLinkDataValidMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->read(*arg2,arg3); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->read(*arg2,arg3); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraLinkDataValidMode_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraLinkDataValidMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0;
    { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraLinkDataValidMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyICameraLinkDataValidMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraLinkDataValidMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraLinkDataValidMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyICameraLinkDataValidMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyICameraLinkDataValidMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyICameraLinkDataValidMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraLinkDataValidMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *,std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *,std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *,std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *,std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *,std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *,std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraLinkDataValidMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraLinkDataValidMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraLinkDataValidMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraLinkDataValidMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraLinkDataValidMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraLinkDataValidMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraLinkDataValidMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraLinkDataValidMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraLinkDataValidMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraLinkDataValidMode_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraLinkDataValidMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyICameraLinkDataValidMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraLinkDataValidMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraLinkDataValidMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraLinkDataValidMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyICameraLinkDataValidMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraLinkDataValidMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *,mvIMPACT::acquire::TCameraLinkDataValidMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *,mvIMPACT::acquire::TCameraLinkDataValidMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *,std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *,std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *,std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode > const *,std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyICameraPixelClock__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyICameraPixelClock",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyICameraPixelClock__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyICameraPixelClock__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyICameraPixelClock'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraPixelClock_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraPixelClock_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraPixelClock_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraPixelClock_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraPixelClock_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyICameraPixelClock_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraPixelClock_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraPixelClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraPixelClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraPixelClock_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraPixelClock_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyICameraPixelClock_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraPixelClock_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraPixelClock_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraPixelClock_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraPixelClock> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraPixelClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraPixelClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraPixelClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraPixelClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraPixelClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraPixelClock> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->read(*arg2,arg3,arg4,arg5); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraPixelClock_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyICameraPixelClock_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraPixelClock_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyICameraPixelClock_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraPixelClock_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraPixelClock_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyICameraPixelClock_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyICameraPixelClock_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyICameraPixelClock_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraPixelClock_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *,std::vector< mvIMPACT::acquire::TCameraPixelClock > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *,std::vector< mvIMPACT::acquire::TCameraPixelClock > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *,std::vector< mvIMPACT::acquire::TCameraPixelClock > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *,std::vector< mvIMPACT::acquire::TCameraPixelClock > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *,std::vector< mvIMPACT::acquire::TCameraPixelClock > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *,std::vector< mvIMPACT::acquire::TCameraPixelClock > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraPixelClock_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraPixelClock_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraPixelClock> * const pV = new std::vector<mvIMPACT::acquire::TCameraPixelClock> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraPixelClock>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraPixelClock,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraPixelClock > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraPixelClock> * const pV = new std::vector<mvIMPACT::acquire::TCameraPixelClock> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraPixelClock>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraPixelClock,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraPixelClock > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraPixelClock> * const pV = new std::vector<mvIMPACT::acquire::TCameraPixelClock> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraPixelClock>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraPixelClock,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraPixelClock > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraPixelClock> * const pV = new std::vector<mvIMPACT::acquire::TCameraPixelClock> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraPixelClock>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraPixelClock,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraPixelClock > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraPixelClock_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraPixelClock_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraPixelClock_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyICameraPixelClock_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraPixelClock_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraPixelClock_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraPixelClock_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyICameraPixelClock_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraPixelClock_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *,mvIMPACT::acquire::TCameraPixelClock,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *,mvIMPACT::acquire::TCameraPixelClock)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *,std::vector< mvIMPACT::acquire::TCameraPixelClock > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *,std::vector< mvIMPACT::acquire::TCameraPixelClock > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *,std::vector< mvIMPACT::acquire::TCameraPixelClock > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock > const *,std::vector< mvIMPACT::acquire::TCameraPixelClock > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyICameraScanMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyICameraScanMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyICameraScanMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyICameraScanMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyICameraScanMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraScanMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraScanMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraScanMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraScanMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraScanMode_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyICameraScanMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraScanMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraScanMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraScanMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraScanMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraScanMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyICameraScanMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraScanMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraScanMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraScanMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraScanMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraScanMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraScanMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraScanMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraScanMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraScanMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraScanMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraScanMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyICameraScanMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraScanMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyICameraScanMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraScanMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraScanMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyICameraScanMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyICameraScanMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyICameraScanMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraScanMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *,std::vector< mvIMPACT::acquire::TCameraScanMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *,std::vector< mvIMPACT::acquire::TCameraScanMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *,std::vector< mvIMPACT::acquire::TCameraScanMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *,std::vector< mvIMPACT::acquire::TCameraScanMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *,std::vector< mvIMPACT::acquire::TCameraScanMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *,std::vector< mvIMPACT::acquire::TCameraScanMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraScanMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraScanMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraScanMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraScanMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraScanMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraScanMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraScanMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraScanMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraScanMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraScanMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraScanMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraScanMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraScanMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraScanMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraScanMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraScanMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraScanMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraScanMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraScanMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraScanMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraScanMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraScanMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraScanMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraScanMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraScanMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraScanMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyICameraScanMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraScanMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraScanMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraScanMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyICameraScanMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraScanMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *,mvIMPACT::acquire::TCameraScanMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *,mvIMPACT::acquire::TCameraScanMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *,std::vector< mvIMPACT::acquire::TCameraScanMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *,std::vector< mvIMPACT::acquire::TCameraScanMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *,std::vector< mvIMPACT::acquire::TCameraScanMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode > const *,std::vector< mvIMPACT::acquire::TCameraScanMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyICameraShutterMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyICameraShutterMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyICameraShutterMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyICameraShutterMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyICameraShutterMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraShutterMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraShutterMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraShutterMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraShutterMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraShutterMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyICameraShutterMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraShutterMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraShutterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraShutterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraShutterMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraShutterMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyICameraShutterMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraShutterMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraShutterMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraShutterMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraShutterMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraShutterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraShutterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraShutterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraShutterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraShutterMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraShutterMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraShutterMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyICameraShutterMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraShutterMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyICameraShutterMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraShutterMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraShutterMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyICameraShutterMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyICameraShutterMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyICameraShutterMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraShutterMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *,std::vector< mvIMPACT::acquire::TCameraShutterMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *,std::vector< mvIMPACT::acquire::TCameraShutterMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *,std::vector< mvIMPACT::acquire::TCameraShutterMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *,std::vector< mvIMPACT::acquire::TCameraShutterMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *,std::vector< mvIMPACT::acquire::TCameraShutterMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *,std::vector< mvIMPACT::acquire::TCameraShutterMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraShutterMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraShutterMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraShutterMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraShutterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraShutterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraShutterMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraShutterMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraShutterMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraShutterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraShutterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraShutterMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraShutterMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraShutterMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraShutterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraShutterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraShutterMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraShutterMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraShutterMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraShutterMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraShutterMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraShutterMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraShutterMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraShutterMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraShutterMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraShutterMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyICameraShutterMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraShutterMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraShutterMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraShutterMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyICameraShutterMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraShutterMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *,mvIMPACT::acquire::TCameraShutterMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *,mvIMPACT::acquire::TCameraShutterMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *,std::vector< mvIMPACT::acquire::TCameraShutterMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *,std::vector< mvIMPACT::acquire::TCameraShutterMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *,std::vector< mvIMPACT::acquire::TCameraShutterMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode > const *,std::vector< mvIMPACT::acquire::TCameraShutterMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyICameraTapsXGeometry__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyICameraTapsXGeometry",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyICameraTapsXGeometry__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyICameraTapsXGeometry__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyICameraTapsXGeometry'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraTapsXGeometry_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraTapsXGeometry_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraTapsXGeometry_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraTapsXGeometry_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyICameraTapsXGeometry_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyICameraTapsXGeometry_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraTapsXGeometry_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTapsXGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTapsXGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraTapsXGeometry_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyICameraTapsXGeometry_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyICameraTapsXGeometry_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraTapsXGeometry_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraTapsXGeometry_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraTapsXGeometry_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraTapsXGeometry> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTapsXGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTapsXGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTapsXGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTapsXGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTapsXGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraTapsXGeometry> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraTapsXGeometry_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyICameraTapsXGeometry_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraTapsXGeometry_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyICameraTapsXGeometry_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraTapsXGeometry_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraTapsXGeometry_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyICameraTapsXGeometry_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyICameraTapsXGeometry_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyICameraTapsXGeometry_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraTapsXGeometry_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *,std::vector< mvIMPACT::acquire::TCameraTapsXGeometry > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *,std::vector< mvIMPACT::acquire::TCameraTapsXGeometry > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *,std::vector< mvIMPACT::acquire::TCameraTapsXGeometry > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *,std::vector< mvIMPACT::acquire::TCameraTapsXGeometry > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *,std::vector< mvIMPACT::acquire::TCameraTapsXGeometry > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *,std::vector< mvIMPACT::acquire::TCameraTapsXGeometry > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraTapsXGeometry_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraTapsXGeometry_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraTapsXGeometry> * const pV = new std::vector<mvIMPACT::acquire::TCameraTapsXGeometry> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraTapsXGeometry>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraTapsXGeometry,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTapsXGeometry > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraTapsXGeometry> * const pV = new std::vector<mvIMPACT::acquire::TCameraTapsXGeometry> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraTapsXGeometry>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraTapsXGeometry,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTapsXGeometry > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraTapsXGeometry> * const pV = new std::vector<mvIMPACT::acquire::TCameraTapsXGeometry> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraTapsXGeometry>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraTapsXGeometry,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTapsXGeometry > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraTapsXGeometry> * const pV = new std::vector<mvIMPACT::acquire::TCameraTapsXGeometry> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraTapsXGeometry>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraTapsXGeometry,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTapsXGeometry > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsXGeometry_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsXGeometry_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraTapsXGeometry_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraTapsXGeometry_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyICameraTapsXGeometry_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraTapsXGeometry_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraTapsXGeometry_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraTapsXGeometry_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyICameraTapsXGeometry_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraTapsXGeometry_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *,mvIMPACT::acquire::TCameraTapsXGeometry,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *,mvIMPACT::acquire::TCameraTapsXGeometry)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *,std::vector< mvIMPACT::acquire::TCameraTapsXGeometry > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *,std::vector< mvIMPACT::acquire::TCameraTapsXGeometry > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *,std::vector< mvIMPACT::acquire::TCameraTapsXGeometry > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry > const *,std::vector< mvIMPACT::acquire::TCameraTapsXGeometry > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyICameraTapsYGeometry__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyICameraTapsYGeometry",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyICameraTapsYGeometry__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyICameraTapsYGeometry__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyICameraTapsYGeometry'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraTapsYGeometry_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraTapsYGeometry_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraTapsYGeometry_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraTapsYGeometry_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyICameraTapsYGeometry_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyICameraTapsYGeometry_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraTapsYGeometry_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTapsYGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTapsYGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraTapsYGeometry_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyICameraTapsYGeometry_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyICameraTapsYGeometry_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraTapsYGeometry_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraTapsYGeometry_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraTapsYGeometry_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraTapsYGeometry> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTapsYGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTapsYGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTapsYGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTapsYGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTapsYGeometry)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraTapsYGeometry> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraTapsYGeometry_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyICameraTapsYGeometry_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraTapsYGeometry_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyICameraTapsYGeometry_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraTapsYGeometry_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraTapsYGeometry_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyICameraTapsYGeometry_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyICameraTapsYGeometry_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyICameraTapsYGeometry_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraTapsYGeometry_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *,std::vector< mvIMPACT::acquire::TCameraTapsYGeometry > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *,std::vector< mvIMPACT::acquire::TCameraTapsYGeometry > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *,std::vector< mvIMPACT::acquire::TCameraTapsYGeometry > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *,std::vector< mvIMPACT::acquire::TCameraTapsYGeometry > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *,std::vector< mvIMPACT::acquire::TCameraTapsYGeometry > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *,std::vector< mvIMPACT::acquire::TCameraTapsYGeometry > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraTapsYGeometry_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraTapsYGeometry_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraTapsYGeometry> * const pV = new std::vector<mvIMPACT::acquire::TCameraTapsYGeometry> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraTapsYGeometry>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraTapsYGeometry,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTapsYGeometry > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraTapsYGeometry> * const pV = new std::vector<mvIMPACT::acquire::TCameraTapsYGeometry> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraTapsYGeometry>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraTapsYGeometry,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTapsYGeometry > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraTapsYGeometry> * const pV = new std::vector<mvIMPACT::acquire::TCameraTapsYGeometry> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraTapsYGeometry>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraTapsYGeometry,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTapsYGeometry > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraTapsYGeometry> * const pV = new std::vector<mvIMPACT::acquire::TCameraTapsYGeometry> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraTapsYGeometry>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraTapsYGeometry,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTapsYGeometry > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTapsYGeometry_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraTapsYGeometry_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraTapsYGeometry_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyICameraTapsYGeometry_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraTapsYGeometry_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraTapsYGeometry_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraTapsYGeometry_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyICameraTapsYGeometry_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraTapsYGeometry_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *,mvIMPACT::acquire::TCameraTapsYGeometry,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *,mvIMPACT::acquire::TCameraTapsYGeometry)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *,std::vector< mvIMPACT::acquire::TCameraTapsYGeometry > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *,std::vector< mvIMPACT::acquire::TCameraTapsYGeometry > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *,std::vector< mvIMPACT::acquire::TCameraTapsYGeometry > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry > const *,std::vector< mvIMPACT::acquire::TCameraTapsYGeometry > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyICameraTriggerMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyICameraTriggerMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyICameraTriggerMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyICameraTriggerMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyICameraTriggerMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraTriggerMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraTriggerMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraTriggerMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraTriggerMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraTriggerMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyICameraTriggerMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraTriggerMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraTriggerMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraTriggerMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyICameraTriggerMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraTriggerMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraTriggerMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraTriggerMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraTriggerMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraTriggerMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraTriggerMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyICameraTriggerMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraTriggerMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyICameraTriggerMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraTriggerMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraTriggerMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyICameraTriggerMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyICameraTriggerMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyICameraTriggerMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraTriggerMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *,std::vector< mvIMPACT::acquire::TCameraTriggerMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *,std::vector< mvIMPACT::acquire::TCameraTriggerMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *,std::vector< mvIMPACT::acquire::TCameraTriggerMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *,std::vector< mvIMPACT::acquire::TCameraTriggerMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *,std::vector< mvIMPACT::acquire::TCameraTriggerMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *,std::vector< mvIMPACT::acquire::TCameraTriggerMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraTriggerMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraTriggerMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraTriggerMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraTriggerMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraTriggerMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraTriggerMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTriggerMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraTriggerMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraTriggerMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraTriggerMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraTriggerMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTriggerMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraTriggerMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraTriggerMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraTriggerMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraTriggerMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTriggerMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraTriggerMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraTriggerMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraTriggerMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraTriggerMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTriggerMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraTriggerMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraTriggerMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyICameraTriggerMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraTriggerMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraTriggerMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraTriggerMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyICameraTriggerMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraTriggerMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *,mvIMPACT::acquire::TCameraTriggerMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *,mvIMPACT::acquire::TCameraTriggerMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *,std::vector< mvIMPACT::acquire::TCameraTriggerMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *,std::vector< mvIMPACT::acquire::TCameraTriggerMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *,std::vector< mvIMPACT::acquire::TCameraTriggerMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode > const *,std::vector< mvIMPACT::acquire::TCameraTriggerMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyICameraTestMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyICameraTestMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyICameraTestMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyICameraTestMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyICameraTestMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraTestMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraTestMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraTestMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraTestMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraTestMode_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyICameraTestMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraTestMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraTestMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraTestMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyICameraTestMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraTestMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraTestMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraTestMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraTestMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraTestMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraTestMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyICameraTestMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraTestMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyICameraTestMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraTestMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraTestMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyICameraTestMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyICameraTestMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyICameraTestMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraTestMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *,std::vector< mvIMPACT::acquire::TCameraTestMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *,std::vector< mvIMPACT::acquire::TCameraTestMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *,std::vector< mvIMPACT::acquire::TCameraTestMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *,std::vector< mvIMPACT::acquire::TCameraTestMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *,std::vector< mvIMPACT::acquire::TCameraTestMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *,std::vector< mvIMPACT::acquire::TCameraTestMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraTestMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraTestMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraTestMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraTestMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraTestMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraTestMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTestMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraTestMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraTestMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraTestMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraTestMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTestMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraTestMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraTestMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraTestMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraTestMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTestMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraTestMode> * const pV = new std::vector<mvIMPACT::acquire::TCameraTestMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraTestMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraTestMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTestMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTestMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTestMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraTestMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraTestMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyICameraTestMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraTestMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraTestMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraTestMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyICameraTestMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraTestMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *,mvIMPACT::acquire::TCameraTestMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *,mvIMPACT::acquire::TCameraTestMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *,std::vector< mvIMPACT::acquire::TCameraTestMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *,std::vector< mvIMPACT::acquire::TCameraTestMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *,std::vector< mvIMPACT::acquire::TCameraTestMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode > const *,std::vector< mvIMPACT::acquire::TCameraTestMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyICameraSerialPortBaudRate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyICameraSerialPortBaudRate",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyICameraSerialPortBaudRate__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyICameraSerialPortBaudRate__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyICameraSerialPortBaudRate'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraSerialPortBaudRate_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraSerialPortBaudRate_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraSerialPortBaudRate_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_getTranslationDictString(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraSerialPortBaudRate_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyICameraSerialPortBaudRate_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyICameraSerialPortBaudRate_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraSerialPortBaudRate_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraSerialPortBaudRate)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraSerialPortBaudRate)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraSerialPortBaudRate_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyICameraSerialPortBaudRate_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyICameraSerialPortBaudRate_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraSerialPortBaudRate_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraSerialPortBaudRate_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraSerialPortBaudRate_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraSerialPortBaudRate)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraSerialPortBaudRate)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraSerialPortBaudRate)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraSerialPortBaudRate)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraSerialPortBaudRate)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->read(*arg2,arg3); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->read(*arg2,arg3); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraSerialPortBaudRate_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyICameraSerialPortBaudRate_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0;
    { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraSerialPortBaudRate_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyICameraSerialPortBaudRate_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraSerialPortBaudRate_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraSerialPortBaudRate_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyICameraSerialPortBaudRate_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyICameraSerialPortBaudRate_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyICameraSerialPortBaudRate_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraSerialPortBaudRate_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *,std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *,std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *,std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *,std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *,std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *,std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraSerialPortBaudRate_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraSerialPortBaudRate_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate> * const pV = new std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraSerialPortBaudRate,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate> * const pV = new std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraSerialPortBaudRate,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate> * const pV = new std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraSerialPortBaudRate,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate> * const pV = new std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraSerialPortBaudRate>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraSerialPortBaudRate,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraSerialPortBaudRate_write(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5]; if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraSerialPortBaudRate_write",0,4,argv))) SWIG_fail;
  --argc; if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraSerialPortBaudRate_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyICameraSerialPortBaudRate_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraSerialPortBaudRate_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraSerialPortBaudRate_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraSerialPortBaudRate_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyICameraSerialPortBaudRate_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraSerialPortBaudRate_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *,mvIMPACT::acquire::TCameraSerialPortBaudRate,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *,mvIMPACT::acquire::TCameraSerialPortBaudRate)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *,std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *,std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *,std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate > const *,std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyICameraTriggerSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyICameraTriggerSource",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyICameraTriggerSource__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyICameraTriggerSource__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyICameraTriggerSource'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraTriggerSource_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraTriggerSource_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraTriggerSource_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraTriggerSource_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyICameraTriggerSource_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyICameraTriggerSource_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraTriggerSource_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTriggerSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTriggerSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraTriggerSource_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyICameraTriggerSource_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyICameraTriggerSource_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraTriggerSource_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyICameraTriggerSource_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyICameraTriggerSource_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraTriggerSource> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTriggerSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTriggerSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTriggerSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTriggerSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TCameraTriggerSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TCameraTriggerSource> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraTriggerSource_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyICameraTriggerSource_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyICameraTriggerSource_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyICameraTriggerSource_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraTriggerSource_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraTriggerSource_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyICameraTriggerSource_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyICameraTriggerSource_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyICameraTriggerSource_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraTriggerSource_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *,std::vector< mvIMPACT::acquire::TCameraTriggerSource > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *,std::vector< mvIMPACT::acquire::TCameraTriggerSource > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *,std::vector< mvIMPACT::acquire::TCameraTriggerSource > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *,std::vector< mvIMPACT::acquire::TCameraTriggerSource > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *,std::vector< mvIMPACT::acquire::TCameraTriggerSource > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *,std::vector< mvIMPACT::acquire::TCameraTriggerSource > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraTriggerSource_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyICameraTriggerSource_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraTriggerSource> * const pV = new std::vector<mvIMPACT::acquire::TCameraTriggerSource> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraTriggerSource>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraTriggerSource,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTriggerSource > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraTriggerSource> * const pV = new std::vector<mvIMPACT::acquire::TCameraTriggerSource> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraTriggerSource>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraTriggerSource,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTriggerSource > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraTriggerSource> * const pV = new std::vector<mvIMPACT::acquire::TCameraTriggerSource> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraTriggerSource>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraTriggerSource,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTriggerSource > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TCameraTriggerSource> * const pV = new std::vector<mvIMPACT::acquire::TCameraTriggerSource> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TCameraTriggerSource>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TCameraTriggerSource,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *)arg1)->write((std::vector< mvIMPACT::acquire::TCameraTriggerSource > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTriggerSource_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyICameraTriggerSource_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyICameraTriggerSource_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyICameraTriggerSource_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyICameraTriggerSource_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyICameraTriggerSource_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyICameraTriggerSource_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyICameraTriggerSource_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyICameraTriggerSource_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyICameraTriggerSource_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *,mvIMPACT::acquire::TCameraTriggerSource,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *,mvIMPACT::acquire::TCameraTriggerSource)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *,std::vector< mvIMPACT::acquire::TCameraTriggerSource > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *,std::vector< mvIMPACT::acquire::TCameraTriggerSource > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *,std::vector< mvIMPACT::acquire::TCameraTriggerSource > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource > const *,std::vector< mvIMPACT::acquire::TCameraTriggerSource > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIClampMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIClampMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIClampMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIClampMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIClampMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIClampMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TClampMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIClampMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TClampMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TClampMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIClampMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIClampMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIClampMode_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIClampMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIClampMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TClampMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TClampMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIClampMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIClampMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIClampMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIClampMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIClampMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIClampMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TClampMode> (0); arg2 = pV; }  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TClampMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TClampMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TClampMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TClampMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TClampMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TClampMode> (0); arg2 = pV; }  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIClampMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIClampMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2; return _wrap_PropertyIClampMode_read__SWIG_4(self, argc, argv);}
   check_2: if (argc == 2) { return _wrap_PropertyIClampMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIClampMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIClampMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIClampMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIClampMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIClampMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIClampMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *,std::vector< mvIMPACT::acquire::TClampMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *,std::vector< mvIMPACT::acquire::TClampMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *,std::vector< mvIMPACT::acquire::TClampMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *,std::vector< mvIMPACT::acquire::TClampMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *,std::vector< mvIMPACT::acquire::TClampMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *,std::vector< mvIMPACT::acquire::TClampMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIClampMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIClampMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TClampMode> * const pV = new std::vector<mvIMPACT::acquire::TClampMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TClampMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TClampMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TClampMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TClampMode> * const pV = new std::vector<mvIMPACT::acquire::TClampMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TClampMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TClampMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TClampMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TClampMode> * const pV = new std::vector<mvIMPACT::acquire::TClampMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TClampMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TClampMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TClampMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TClampMode> * const pV = new std::vector<mvIMPACT::acquire::TClampMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TClampMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TClampMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TClampMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIClampMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIClampMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIClampMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIClampMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; return _wrap_PropertyIClampMode_write__SWIG_2(self, argc, argv);}
   check_3: if (argc == 3) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIClampMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIClampMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIClampMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIClampMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *,mvIMPACT::acquire::TClampMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *,mvIMPACT::acquire::TClampMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *,std::vector< mvIMPACT::acquire::TClampMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *,std::vector< mvIMPACT::acquire::TClampMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *,std::vector< mvIMPACT::acquire::TClampMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode > const *,std::vector< mvIMPACT::acquire::TClampMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIDeviceAdvancedOptions__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDeviceAdvancedOptions",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIDeviceAdvancedOptions__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDeviceAdvancedOptions__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDeviceAdvancedOptions'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceAdvancedOptions_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceAdvancedOptions_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceAdvancedOptions_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceAdvancedOptions_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDeviceAdvancedOptions_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDeviceAdvancedOptions_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceAdvancedOptions_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceAdvancedOptions)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceAdvancedOptions)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceAdvancedOptions_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDeviceAdvancedOptions_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDeviceAdvancedOptions_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceAdvancedOptions_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceAdvancedOptions_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceAdvancedOptions_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceAdvancedOptions)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceAdvancedOptions)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceAdvancedOptions)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceAdvancedOptions)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceAdvancedOptions)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->read(*arg2,arg3,arg4); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->read(*arg2,arg3,arg4); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceAdvancedOptions_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceAdvancedOptions_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; {
      { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceAdvancedOptions_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDeviceAdvancedOptions_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceAdvancedOptions_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceAdvancedOptions_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDeviceAdvancedOptions_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDeviceAdvancedOptions_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDeviceAdvancedOptions_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceAdvancedOptions_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *,std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *,std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *,std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *,std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *,std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *,std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceAdvancedOptions_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceAdvancedOptions_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions> * const pV = new std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceAdvancedOptions,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions> * const pV = new std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceAdvancedOptions,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions> * const pV = new std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceAdvancedOptions,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions> * const pV = new std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceAdvancedOptions>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceAdvancedOptions,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceAdvancedOptions_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceAdvancedOptions_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceAdvancedOptions_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceAdvancedOptions_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDeviceAdvancedOptions_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceAdvancedOptions_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceAdvancedOptions_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceAdvancedOptions_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDeviceAdvancedOptions_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceAdvancedOptions_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *,mvIMPACT::acquire::TDeviceAdvancedOptions,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *,mvIMPACT::acquire::TDeviceAdvancedOptions)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *,std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *,std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *,std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions > const *,std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIDeviceDigitalOutputMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDeviceDigitalOutputMode",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyIDeviceDigitalOutputMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDeviceDigitalOutputMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDeviceDigitalOutputMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceDigitalOutputMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceDigitalOutputMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceDigitalOutputMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceDigitalOutputMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceDigitalOutputMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceDigitalOutputMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceDigitalOutputMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceDigitalOutputMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceDigitalOutputMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceDigitalOutputMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceDigitalOutputMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceDigitalOutputMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceDigitalOutputMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceDigitalOutputMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceDigitalOutputMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->read(*arg2,arg3); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->read(*arg2,arg3); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceDigitalOutputMode_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0;
    { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDeviceDigitalOutputMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceDigitalOutputMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *,std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *,std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *,std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *,std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *,std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *,std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceDigitalOutputMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceDigitalOutputMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceDigitalOutputMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceDigitalOutputMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceDigitalOutputMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceDigitalOutputMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceDigitalOutputMode_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceDigitalOutputMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDeviceDigitalOutputMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceDigitalOutputMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceDigitalOutputMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceDigitalOutputMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDeviceDigitalOutputMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceDigitalOutputMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *,mvIMPACT::acquire::TDeviceDigitalOutputMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *,mvIMPACT::acquire::TDeviceDigitalOutputMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *,std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *,std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *,std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode > const *,std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIDeviceEventMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceEventMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *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_PropertyIDeviceEventMode" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceEventMode(PyObject *self, PyObject *args) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDeviceEventMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIDeviceEventMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDeviceEventMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDeviceEventMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceEventMode > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args,"PropertyIDeviceEventMode_getTranslationDict",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceEventMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceEventMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceEventMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceEventMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceEventMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceEventMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 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__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceEventMode_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 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__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceEventMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceEventMode_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIDeviceEventMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceEventMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceEventMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceEventMode_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceEventMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceEventMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceEventMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceEventMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceEventMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIDeviceEventMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceEventMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 0 ;
  std::vector< std::string > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ;
  PyObject *swig_obj[2] ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args,"PropertyIDeviceEventMode_getTranslationDictStrings",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceEventMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceEventMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceEventMode > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args,"PropertyIDeviceEventMode_getTranslationDictValues",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceEventMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceEventMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceEventMode result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceEventMode_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceEventMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceEventMode result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceEventMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceEventMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceEventMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceEventMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceEventMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceEventMode result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceEventMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceEventMode > *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__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceEventMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceEventMode> (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceEventMode_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 '" "PropertyIDeviceEventMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceEventMode > *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__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceEventMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceEventMode> (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceEventMode_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceEventMode > *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__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceEventMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceEventMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceEventMode > *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__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceEventMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceEventMode> (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceEventMode_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 '" "PropertyIDeviceEventMode_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 '" "PropertyIDeviceEventMode_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceEventMode > *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__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceEventMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceEventMode> (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceEventMode_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 '" "PropertyIDeviceEventMode_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceEventMode > *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__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceEventMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceEventMode> (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceEventMode_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceEventMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIDeviceEventMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceEventMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDeviceEventMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceEventMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceEventMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDeviceEventMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDeviceEventMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDeviceEventMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceEventMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *,std::vector< mvIMPACT::acquire::TDeviceEventMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *,std::vector< mvIMPACT::acquire::TDeviceEventMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *,std::vector< mvIMPACT::acquire::TDeviceEventMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *,std::vector< mvIMPACT::acquire::TDeviceEventMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *,std::vector< mvIMPACT::acquire::TDeviceEventMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *,std::vector< mvIMPACT::acquire::TDeviceEventMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 0 ;
  mvIMPACT::acquire::TDeviceEventMode arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceEventMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceEventMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceEventMode >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceEventMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 0 ;
  mvIMPACT::acquire::TDeviceEventMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceEventMode_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceEventMode""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceEventMode >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceEventMode > *arg2 = 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1); {
    if (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceEventMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceEventMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceEventMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceEventMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceEventMode_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceEventMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceEventMode > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1); {
    if (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceEventMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceEventMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceEventMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceEventMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceEventMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceEventMode > *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::TDeviceEventMode > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1); {
    if (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceEventMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceEventMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceEventMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceEventMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceEventMode_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 '" "PropertyIDeviceEventMode_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceEventMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceEventMode > *arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventMode_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1); {
    if (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceEventMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceEventMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceEventMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceEventMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceEventMode_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceEventMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceEventMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceEventMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDeviceEventMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceEventMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceEventMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceEventMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDeviceEventMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceEventMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *,mvIMPACT::acquire::TDeviceEventMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *,mvIMPACT::acquire::TDeviceEventMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *,std::vector< mvIMPACT::acquire::TDeviceEventMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *,std::vector< mvIMPACT::acquire::TDeviceEventMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *,std::vector< mvIMPACT::acquire::TDeviceEventMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > const *,std::vector< mvIMPACT::acquire::TDeviceEventMode > const &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDeviceEventMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *) 0 ;
  void *argp1 = 0 ; int res1 = 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__TDeviceEventMode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDeviceEventMode" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDeviceEventMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

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

SWIGINTERN PyObject *_wrap_new_PropertyIDeviceEventType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceEventType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::HOBJ arg1 ; int val1 ; int ecode1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *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_PropertyIDeviceEventType" "', argument " "1"" of type '" "mvIMPACT::acquire::HOBJ""'"); }
    arg1 = static_cast< mvIMPACT::acquire::HOBJ >(val1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_PropertyIDeviceEventType(PyObject *self, PyObject *args) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDeviceEventType",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIDeviceEventType__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDeviceEventType__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDeviceEventType'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_getTranslationDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 0 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceEventType > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args,"PropertyIDeviceEventType_getTranslationDict",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_getTranslationDict" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceEventType_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceEventType_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceEventType > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceEventType_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceEventType > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceEventType > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 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__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceEventType_getTranslationDictString" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_getTranslationDictString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 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__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_getTranslationDictString" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceEventType_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceEventType_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIDeviceEventType_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceEventType_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceEventType result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceEventType_getTranslationDictValue" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceEventType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceEventType result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_getTranslationDictValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceEventType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceEventType_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceEventType_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIDeviceEventType_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceEventType_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_getTranslationDictStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 0 ;
  std::vector< std::string > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ;
  PyObject *swig_obj[2] ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args,"PropertyIDeviceEventType_getTranslationDictStrings",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_getTranslationDictStrings" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceEventType_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceEventType_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_getTranslationDictValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceEventType > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args,"PropertyIDeviceEventType_getTranslationDictValues",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_getTranslationDictValues" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceEventType> * const pV = new std::vector<mvIMPACT::acquire::TDeviceEventType> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 0 ;
  int arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mvIMPACT::acquire::TDeviceEventType result;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceEventType_read" "', argument " "2"" of type '" "int""'"); }
    arg2 = static_cast< int >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceEventType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; mvIMPACT::acquire::TDeviceEventType result; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceEventType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_getMaxValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceEventType result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_getMaxValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceEventType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_getMinValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceEventType result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_getMinValue" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceEventType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_getStepWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::TDeviceEventType result; if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_getStepWidth" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceEventType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceEventType > *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__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceEventType> * const pV = new std::vector<mvIMPACT::acquire::TDeviceEventType> (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceEventType_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 '" "PropertyIDeviceEventType_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceEventType > *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__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceEventType> * const pV = new std::vector<mvIMPACT::acquire::TDeviceEventType> (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceEventType_read" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceEventType > *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__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceEventType> * const pV = new std::vector<mvIMPACT::acquire::TDeviceEventType> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceEventType > *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__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceEventType> * const pV = new std::vector<mvIMPACT::acquire::TDeviceEventType> (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceEventType_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 '" "PropertyIDeviceEventType_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 '" "PropertyIDeviceEventType_read" "', argument " "5"" of type '" "int""'"); }
    arg5 = static_cast< int >(val5); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->read(*arg2,arg3,arg4,arg5); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceEventType > *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__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceEventType> * const pV = new std::vector<mvIMPACT::acquire::TDeviceEventType> (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceEventType_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 '" "PropertyIDeviceEventType_read" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceEventType > *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__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_read" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1); {
    if (!PyList_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a list."); SWIG_fail; } 
    std::vector<mvIMPACT::acquire::TDeviceEventType> * const pV = new std::vector<mvIMPACT::acquire::TDeviceEventType> (0);
    arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceEventType_read" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceEventType_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIDeviceEventType_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceEventType_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDeviceEventType_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceEventType_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceEventType_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDeviceEventType_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDeviceEventType_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDeviceEventType_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceEventType_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *,std::vector< mvIMPACT::acquire::TDeviceEventType > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *,std::vector< mvIMPACT::acquire::TDeviceEventType > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *,std::vector< mvIMPACT::acquire::TDeviceEventType > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *,std::vector< mvIMPACT::acquire::TDeviceEventType > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *,std::vector< mvIMPACT::acquire::TDeviceEventType > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *,std::vector< mvIMPACT::acquire::TDeviceEventType > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 0 ;
  mvIMPACT::acquire::TDeviceEventType arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceEventType_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceEventType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceEventType >(val2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceEventType_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 0 ;
  mvIMPACT::acquire::TDeviceEventType arg2 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropertyIDeviceEventType_write" "', argument " "2"" of type '" "mvIMPACT::acquire::TDeviceEventType""'"); }
    arg2 = static_cast< mvIMPACT::acquire::TDeviceEventType >(val2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceEventType > *arg2 = 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1); {
    if (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceEventType> * const pV = new std::vector<mvIMPACT::acquire::TDeviceEventType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceEventType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceEventType,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceEventType_write" "', argument " "3"" of type '" "int""'"); }
    arg3 = static_cast< int >(val3); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceEventType > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceEventType > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *result = 0 ;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1); {
    if (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceEventType> * const pV = new std::vector<mvIMPACT::acquire::TDeviceEventType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceEventType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceEventType,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceEventType > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceEventType > *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::TDeviceEventType > *result = 0 ;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1); {
    if (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceEventType> * const pV = new std::vector<mvIMPACT::acquire::TDeviceEventType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceEventType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceEventType,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceEventType_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 '" "PropertyIDeviceEventType_write" "', argument " "4"" of type '" "int""'"); }
    arg4 = static_cast< int >(val4); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceEventType > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 0 ;
  std::vector< mvIMPACT::acquire::TDeviceEventType > *arg2 = 0 ; bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *result = 0 ;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertyIDeviceEventType_write" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1); {
    if (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceEventType> * const pV = new std::vector<mvIMPACT::acquire::TDeviceEventType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceEventType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceEventType,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertyIDeviceEventType_write" "', argument " "3"" of type '" "bool""'"); }
    arg3 = static_cast< bool >(val3); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceEventType > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceEventType_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceEventType_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceEventType_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDeviceEventType_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceEventType_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceEventType_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceEventType_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDeviceEventType_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceEventType_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *,mvIMPACT::acquire::TDeviceEventType,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *,mvIMPACT::acquire::TDeviceEventType)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *,std::vector< mvIMPACT::acquire::TDeviceEventType > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *,std::vector< mvIMPACT::acquire::TDeviceEventType > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *,std::vector< mvIMPACT::acquire::TDeviceEventType > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > const *,std::vector< mvIMPACT::acquire::TDeviceEventType > const &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_delete_PropertyIDeviceEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *arg1 = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *) 0 ;
  void *argp1 = 0 ; int res1 = 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__TDeviceEventType_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropertyIDeviceEventType" "', argument " "1"" of type '" "mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > * >(argp1); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *PropertyIDeviceEventType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

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

SWIGINTERN PyObject *_wrap_new_PropertyIDeviceImageTrigger__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDeviceImageTrigger",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIDeviceImageTrigger__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDeviceImageTrigger__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDeviceImageTrigger'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceImageTrigger_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceImageTrigger_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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 *_wrap_PropertyIDeviceImageTrigger_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceImageTrigger_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDeviceImageTrigger_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDeviceImageTrigger_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceImageTrigger_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceImageTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceImageTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceImageTrigger_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceImageTrigger_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDeviceImageTrigger_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceImageTrigger_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceImageTrigger_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceImageTrigger_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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 *_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceImageTrigger> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceImageTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceImageTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceImageTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceImageTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceImageTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->read(*arg2,arg3,arg4); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceImageTrigger> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->read(*arg2,arg3,arg4); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceImageTrigger_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIDeviceImageTrigger_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceImageTrigger_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDeviceImageTrigger_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceImageTrigger_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceImageTrigger_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDeviceImageTrigger_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDeviceImageTrigger_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDeviceImageTrigger_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceImageTrigger_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *,std::vector< mvIMPACT::acquire::TDeviceImageTrigger > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *,std::vector< mvIMPACT::acquire::TDeviceImageTrigger > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *,std::vector< mvIMPACT::acquire::TDeviceImageTrigger > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *,std::vector< mvIMPACT::acquire::TDeviceImageTrigger > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *,std::vector< mvIMPACT::acquire::TDeviceImageTrigger > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *,std::vector< mvIMPACT::acquire::TDeviceImageTrigger > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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 *_wrap_PropertyIDeviceImageTrigger_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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 *_wrap_PropertyIDeviceImageTrigger_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceImageTrigger> * const pV = new std::vector<mvIMPACT::acquire::TDeviceImageTrigger> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceImageTrigger>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceImageTrigger,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceImageTrigger > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceImageTrigger> * const pV = new std::vector<mvIMPACT::acquire::TDeviceImageTrigger> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceImageTrigger>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceImageTrigger,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceImageTrigger > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceImageTrigger> * const pV = new std::vector<mvIMPACT::acquire::TDeviceImageTrigger> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceImageTrigger>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceImageTrigger,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceImageTrigger > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceImageTrigger> * const pV = new std::vector<mvIMPACT::acquire::TDeviceImageTrigger> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceImageTrigger>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceImageTrigger,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceImageTrigger > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceImageTrigger_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceImageTrigger_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceImageTrigger_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceImageTrigger_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDeviceImageTrigger_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceImageTrigger_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceImageTrigger_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceImageTrigger_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDeviceImageTrigger_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceImageTrigger_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *,mvIMPACT::acquire::TDeviceImageTrigger,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *,mvIMPACT::acquire::TDeviceImageTrigger)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *,std::vector< mvIMPACT::acquire::TDeviceImageTrigger > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *,std::vector< mvIMPACT::acquire::TDeviceImageTrigger > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *,std::vector< mvIMPACT::acquire::TDeviceImageTrigger > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger > const *,std::vector< mvIMPACT::acquire::TDeviceImageTrigger > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIDevicePowerMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDevicePowerMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIDevicePowerMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDevicePowerMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDevicePowerMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDevicePowerMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDevicePowerMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDevicePowerMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDevicePowerMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDevicePowerMode_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIDevicePowerMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDevicePowerMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDevicePowerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDevicePowerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDevicePowerMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDevicePowerMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIDevicePowerMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDevicePowerMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDevicePowerMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDevicePowerMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDevicePowerMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDevicePowerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDevicePowerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDevicePowerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDevicePowerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDevicePowerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDevicePowerMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDevicePowerMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIDevicePowerMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDevicePowerMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDevicePowerMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDevicePowerMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDevicePowerMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDevicePowerMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDevicePowerMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDevicePowerMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDevicePowerMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *,std::vector< mvIMPACT::acquire::TDevicePowerMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *,std::vector< mvIMPACT::acquire::TDevicePowerMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *,std::vector< mvIMPACT::acquire::TDevicePowerMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *,std::vector< mvIMPACT::acquire::TDevicePowerMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *,std::vector< mvIMPACT::acquire::TDevicePowerMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *,std::vector< mvIMPACT::acquire::TDevicePowerMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDevicePowerMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDevicePowerMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDevicePowerMode> * const pV = new std::vector<mvIMPACT::acquire::TDevicePowerMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDevicePowerMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDevicePowerMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDevicePowerMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDevicePowerMode> * const pV = new std::vector<mvIMPACT::acquire::TDevicePowerMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDevicePowerMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDevicePowerMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDevicePowerMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDevicePowerMode> * const pV = new std::vector<mvIMPACT::acquire::TDevicePowerMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDevicePowerMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDevicePowerMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDevicePowerMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDevicePowerMode> * const pV = new std::vector<mvIMPACT::acquire::TDevicePowerMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDevicePowerMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDevicePowerMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDevicePowerMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDevicePowerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDevicePowerMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDevicePowerMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDevicePowerMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDevicePowerMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDevicePowerMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDevicePowerMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDevicePowerMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDevicePowerMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDevicePowerMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *,mvIMPACT::acquire::TDevicePowerMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *,mvIMPACT::acquire::TDevicePowerMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *,std::vector< mvIMPACT::acquire::TDevicePowerMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *,std::vector< mvIMPACT::acquire::TDevicePowerMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *,std::vector< mvIMPACT::acquire::TDevicePowerMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode > const *,std::vector< mvIMPACT::acquire::TDevicePowerMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIDeviceScanRateMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDeviceScanRateMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIDeviceScanRateMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDeviceScanRateMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDeviceScanRateMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceScanRateMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceScanRateMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceScanRateMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceScanRateMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDeviceScanRateMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDeviceScanRateMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceScanRateMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceScanRateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceScanRateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceScanRateMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceScanRateMode_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDeviceScanRateMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceScanRateMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceScanRateMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceScanRateMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceScanRateMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceScanRateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceScanRateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceScanRateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceScanRateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceScanRateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->read(*arg2,arg3,arg4); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceScanRateMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->read(*arg2,arg3,arg4); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceScanRateMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIDeviceScanRateMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceScanRateMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDeviceScanRateMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceScanRateMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceScanRateMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDeviceScanRateMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDeviceScanRateMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDeviceScanRateMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceScanRateMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *,std::vector< mvIMPACT::acquire::TDeviceScanRateMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *,std::vector< mvIMPACT::acquire::TDeviceScanRateMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *,std::vector< mvIMPACT::acquire::TDeviceScanRateMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *,std::vector< mvIMPACT::acquire::TDeviceScanRateMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *,std::vector< mvIMPACT::acquire::TDeviceScanRateMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *,std::vector< mvIMPACT::acquire::TDeviceScanRateMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceScanRateMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceScanRateMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceScanRateMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceScanRateMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceScanRateMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceScanRateMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceScanRateMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceScanRateMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceScanRateMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceScanRateMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceScanRateMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceScanRateMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceScanRateMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceScanRateMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceScanRateMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceScanRateMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceScanRateMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceScanRateMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceScanRateMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceScanRateMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceScanRateMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceScanRateMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceScanRateMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceScanRateMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceScanRateMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceScanRateMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDeviceScanRateMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceScanRateMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceScanRateMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceScanRateMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDeviceScanRateMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceScanRateMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *,mvIMPACT::acquire::TDeviceScanRateMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *,mvIMPACT::acquire::TDeviceScanRateMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *,std::vector< mvIMPACT::acquire::TDeviceScanRateMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *,std::vector< mvIMPACT::acquire::TDeviceScanRateMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *,std::vector< mvIMPACT::acquire::TDeviceScanRateMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode > const *,std::vector< mvIMPACT::acquire::TDeviceScanRateMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIDeviceSignalOutputStartEvent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDeviceSignalOutputStartEvent",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyIDeviceSignalOutputStartEvent__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDeviceSignalOutputStartEvent__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDeviceSignalOutputStartEvent'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceSignalOutputStartEvent_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceSignalOutputStartEvent_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > * >(argp2);
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceSignalOutputStartEvent_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictString(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceSignalOutputStartEvent_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) {
    return _wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceSignalOutputStartEvent_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceSignalOutputStartEvent)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceSignalOutputStartEvent)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictValue(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceSignalOutputStartEvent_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictValue__SWIG_1(self, argc, argv);}
   if (argc == 2) { return _wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictValue__SWIG_0(self, argc, argv);} 
  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceSignalOutputStartEvent_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceSignalOutputStartEvent_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceSignalOutputStartEvent_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceSignalOutputStartEvent)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceSignalOutputStartEvent)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceSignalOutputStartEvent)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceSignalOutputStartEvent)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceSignalOutputStartEvent)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->read(*arg2); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->read(*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_read(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceSignalOutputStartEvent_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_1(self, argc, argv);}  if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDeviceSignalOutputStartEvent_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceSignalOutputStartEvent_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *,std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *,std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *,std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *,std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *,std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *,std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceSignalOutputStartEvent_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceSignalOutputStartEvent_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent> * const pV = new std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceSignalOutputStartEvent,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent> * const pV = new std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceSignalOutputStartEvent,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent> * const pV = new std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceSignalOutputStartEvent,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent> * const pV = new std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceSignalOutputStartEvent>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceSignalOutputStartEvent,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSignalOutputStartEvent_write(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceSignalOutputStartEvent_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceSignalOutputStartEvent_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDeviceSignalOutputStartEvent_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceSignalOutputStartEvent_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0;
    { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceSignalOutputStartEvent_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceSignalOutputStartEvent_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDeviceSignalOutputStartEvent_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceSignalOutputStartEvent_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *,mvIMPACT::acquire::TDeviceSignalOutputStartEvent,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *,mvIMPACT::acquire::TDeviceSignalOutputStartEvent)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *,std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *,std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *,std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const *,std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIDeviceSyncOutMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDeviceSyncOutMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIDeviceSyncOutMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDeviceSyncOutMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDeviceSyncOutMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceSyncOutMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceSyncOutMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceSyncOutMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceSyncOutMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceSyncOutMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDeviceSyncOutMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceSyncOutMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceSyncOutMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceSyncOutMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceSyncOutMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceSyncOutMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIDeviceSyncOutMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceSyncOutMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceSyncOutMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceSyncOutMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceSyncOutMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceSyncOutMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceSyncOutMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceSyncOutMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceSyncOutMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceSyncOutMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceSyncOutMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceSyncOutMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIDeviceSyncOutMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceSyncOutMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDeviceSyncOutMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceSyncOutMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceSyncOutMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDeviceSyncOutMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDeviceSyncOutMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDeviceSyncOutMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceSyncOutMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *,std::vector< mvIMPACT::acquire::TDeviceSyncOutMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *,std::vector< mvIMPACT::acquire::TDeviceSyncOutMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *,std::vector< mvIMPACT::acquire::TDeviceSyncOutMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *,std::vector< mvIMPACT::acquire::TDeviceSyncOutMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *,std::vector< mvIMPACT::acquire::TDeviceSyncOutMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *,std::vector< mvIMPACT::acquire::TDeviceSyncOutMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceSyncOutMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceSyncOutMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceSyncOutMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceSyncOutMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceSyncOutMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceSyncOutMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceSyncOutMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceSyncOutMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceSyncOutMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceSyncOutMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceSyncOutMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceSyncOutMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceSyncOutMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceSyncOutMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceSyncOutMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceSyncOutMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceSyncOutMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceSyncOutMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceSyncOutMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceSyncOutMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceSyncOutMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceSyncOutMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceSyncOutMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceSyncOutMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceSyncOutMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceSyncOutMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDeviceSyncOutMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceSyncOutMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceSyncOutMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceSyncOutMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDeviceSyncOutMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceSyncOutMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *,mvIMPACT::acquire::TDeviceSyncOutMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *,mvIMPACT::acquire::TDeviceSyncOutMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *,std::vector< mvIMPACT::acquire::TDeviceSyncOutMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *,std::vector< mvIMPACT::acquire::TDeviceSyncOutMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *,std::vector< mvIMPACT::acquire::TDeviceSyncOutMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode > const *,std::vector< mvIMPACT::acquire::TDeviceSyncOutMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIDeviceTriggerInterface__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDeviceTriggerInterface",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyIDeviceTriggerInterface__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDeviceTriggerInterface__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDeviceTriggerInterface'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceTriggerInterface_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceTriggerInterface_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceTriggerInterface_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceTriggerInterface_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDeviceTriggerInterface_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDeviceTriggerInterface_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceTriggerInterface_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceTriggerInterface)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceTriggerInterface)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceTriggerInterface_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDeviceTriggerInterface_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDeviceTriggerInterface_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceTriggerInterface_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceTriggerInterface_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceTriggerInterface_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerInterface> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceTriggerInterface)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceTriggerInterface)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceTriggerInterface)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceTriggerInterface)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceTriggerInterface)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerInterface> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceTriggerInterface_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceTriggerInterface_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; {
      { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceTriggerInterface_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDeviceTriggerInterface_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceTriggerInterface_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceTriggerInterface_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDeviceTriggerInterface_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDeviceTriggerInterface_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDeviceTriggerInterface_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceTriggerInterface_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerInterface > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerInterface > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerInterface > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerInterface > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerInterface > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerInterface > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceTriggerInterface_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceTriggerInterface_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceTriggerInterface> * const pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerInterface> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceTriggerInterface>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceTriggerInterface,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerInterface > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceTriggerInterface> * const pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerInterface> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceTriggerInterface>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceTriggerInterface,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerInterface > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceTriggerInterface> * const pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerInterface> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceTriggerInterface>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceTriggerInterface,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerInterface > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceTriggerInterface> * const pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerInterface> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceTriggerInterface>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceTriggerInterface,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerInterface > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerInterface_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerInterface_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceTriggerInterface_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceTriggerInterface_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDeviceTriggerInterface_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceTriggerInterface_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceTriggerInterface_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceTriggerInterface_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDeviceTriggerInterface_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceTriggerInterface_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *,mvIMPACT::acquire::TDeviceTriggerInterface,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *,mvIMPACT::acquire::TDeviceTriggerInterface)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerInterface > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerInterface > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerInterface > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerInterface > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIDeviceTriggerMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDeviceTriggerMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIDeviceTriggerMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDeviceTriggerMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDeviceTriggerMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceTriggerMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceTriggerMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceTriggerMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceTriggerMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceTriggerMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDeviceTriggerMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceTriggerMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceTriggerMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDeviceTriggerMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIDeviceTriggerMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceTriggerMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDeviceTriggerMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDeviceTriggerMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceTriggerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceTriggerMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIDeviceTriggerMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDeviceTriggerMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDeviceTriggerMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceTriggerMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceTriggerMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDeviceTriggerMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDeviceTriggerMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDeviceTriggerMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceTriggerMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceTriggerMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDeviceTriggerMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceTriggerMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceTriggerMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceTriggerMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceTriggerMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceTriggerMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceTriggerMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceTriggerMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceTriggerMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceTriggerMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDeviceTriggerMode> * const pV = new std::vector<mvIMPACT::acquire::TDeviceTriggerMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDeviceTriggerMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDeviceTriggerMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDeviceTriggerMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceTriggerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDeviceTriggerMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDeviceTriggerMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDeviceTriggerMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDeviceTriggerMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDeviceTriggerMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDeviceTriggerMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDeviceTriggerMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDeviceTriggerMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDeviceTriggerMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *,mvIMPACT::acquire::TDeviceTriggerMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *,mvIMPACT::acquire::TDeviceTriggerMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode > const *,std::vector< mvIMPACT::acquire::TDeviceTriggerMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIDigIOState__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDigIOState",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIDigIOState__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDigIOState__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDigIOState'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDigIOState_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDigIOState > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDigIOState_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDigIOState > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDigIOState > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDigIOState_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDigIOState_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDigIOState_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIDigIOState_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDigIOState_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigIOState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigIOState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDigIOState_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDigIOState_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIDigIOState_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDigIOState_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDigIOState_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDigIOState_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDigIOState> (0); arg2 = pV; } 
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigIOState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigIOState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigIOState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigIOState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigIOState)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDigIOState> (0); arg2 = pV; } 
  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->read(*arg2,arg3,arg4,arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDigIOState_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIDigIOState_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDigIOState_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDigIOState_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDigIOState_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDigIOState_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDigIOState_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDigIOState_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDigIOState_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDigIOState_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *,std::vector< mvIMPACT::acquire::TDigIOState > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *,std::vector< mvIMPACT::acquire::TDigIOState > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *,std::vector< mvIMPACT::acquire::TDigIOState > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *,std::vector< mvIMPACT::acquire::TDigIOState > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *,std::vector< mvIMPACT::acquire::TDigIOState > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *,std::vector< mvIMPACT::acquire::TDigIOState > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDigIOState_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDigIOState_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDigIOState> * const pV = new std::vector<mvIMPACT::acquire::TDigIOState> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDigIOState>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDigIOState,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigIOState > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDigIOState> * const pV = new std::vector<mvIMPACT::acquire::TDigIOState> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDigIOState>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDigIOState,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigIOState > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDigIOState> * const pV = new std::vector<mvIMPACT::acquire::TDigIOState> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDigIOState>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDigIOState,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigIOState > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDigIOState> * const pV = new std::vector<mvIMPACT::acquire::TDigIOState> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDigIOState>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDigIOState,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigIOState > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigIOState_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigIOState_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDigIOState_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDigIOState_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDigIOState_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; return _wrap_PropertyIDigIOState_write__SWIG_2(self, argc, argv);}
   check_3: if (argc == 3) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDigIOState_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDigIOState_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDigIOState_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDigIOState_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *,mvIMPACT::acquire::TDigIOState,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *,mvIMPACT::acquire::TDigIOState)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *,std::vector< mvIMPACT::acquire::TDigIOState > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *,std::vector< mvIMPACT::acquire::TDigIOState > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *,std::vector< mvIMPACT::acquire::TDigIOState > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState > const *,std::vector< mvIMPACT::acquire::TDigIOState > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIDigitalIOMeasurementMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDigitalIOMeasurementMode",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyIDigitalIOMeasurementMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDigitalIOMeasurementMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDigitalIOMeasurementMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDigitalIOMeasurementMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDigitalIOMeasurementMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDigitalIOMeasurementMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictString(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDigitalIOMeasurementMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDigitalIOMeasurementMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalIOMeasurementMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalIOMeasurementMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDigitalIOMeasurementMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDigitalIOMeasurementMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDigitalIOMeasurementMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDigitalIOMeasurementMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalIOMeasurementMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalIOMeasurementMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalIOMeasurementMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalIOMeasurementMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalIOMeasurementMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->read(*arg2,arg3); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->read(*arg2,arg3); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDigitalIOMeasurementMode_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0;
    { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDigitalIOMeasurementMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDigitalIOMeasurementMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *,std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *,std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *,std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *,std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *,std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *,std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDigitalIOMeasurementMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDigitalIOMeasurementMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode> * const pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDigitalIOMeasurementMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode> * const pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDigitalIOMeasurementMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode> * const pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDigitalIOMeasurementMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode> * const pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDigitalIOMeasurementMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDigitalIOMeasurementMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementMode_write(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5]; if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDigitalIOMeasurementMode_write",0,4,argv))) SWIG_fail;
  --argc; if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDigitalIOMeasurementMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDigitalIOMeasurementMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDigitalIOMeasurementMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDigitalIOMeasurementMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDigitalIOMeasurementMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDigitalIOMeasurementMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDigitalIOMeasurementMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *,mvIMPACT::acquire::TDigitalIOMeasurementMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *,mvIMPACT::acquire::TDigitalIOMeasurementMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *,std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *,std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *,std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode > const *,std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIDigitalIOMeasurementSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[2]; if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDigitalIOMeasurementSource",0,1,argv))) SWIG_fail;
  --argc; if (argc == 0) { return _wrap_new_PropertyIDigitalIOMeasurementSource__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDigitalIOMeasurementSource__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDigitalIOMeasurementSource'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDigitalIOMeasurementSource_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDigitalIOMeasurementSource_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDigitalIOMeasurementSource_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictString(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDigitalIOMeasurementSource_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictString__SWIG_1(self, argc, argv);}
   if (argc == 2) { return _wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDigitalIOMeasurementSource_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalIOMeasurementSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalIOMeasurementSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictValue(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDigitalIOMeasurementSource_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDigitalIOMeasurementSource_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDigitalIOMeasurementSource_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDigitalIOMeasurementSource_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalIOMeasurementSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalIOMeasurementSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalIOMeasurementSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalIOMeasurementSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalIOMeasurementSource)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->read(*arg2,arg3); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->read(*arg2,arg3); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_read(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[6]; if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDigitalIOMeasurementSource_read",0,5,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_1(self, argc, argv);}  if (argc == 2) {
    int _v = 0; { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDigitalIOMeasurementSource_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDigitalIOMeasurementSource_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *,std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *,std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *,std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *,std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *,std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *,std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDigitalIOMeasurementSource_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDigitalIOMeasurementSource_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource> * const pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDigitalIOMeasurementSource,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource> * const pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDigitalIOMeasurementSource,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource> * const pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDigitalIOMeasurementSource,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource> * const pV = new std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDigitalIOMeasurementSource>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDigitalIOMeasurementSource,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementSource_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalIOMeasurementSource_write(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDigitalIOMeasurementSource_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDigitalIOMeasurementSource_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDigitalIOMeasurementSource_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDigitalIOMeasurementSource_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; {
      { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDigitalIOMeasurementSource_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDigitalIOMeasurementSource_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDigitalIOMeasurementSource_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDigitalIOMeasurementSource_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *,mvIMPACT::acquire::TDigitalIOMeasurementSource,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *,mvIMPACT::acquire::TDigitalIOMeasurementSource)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *,std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *,std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *,std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource > const *,std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIDigitalOutputControlMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDigitalOutputControlMode",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyIDigitalOutputControlMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDigitalOutputControlMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDigitalOutputControlMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDigitalOutputControlMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDigitalOutputControlMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDigitalOutputControlMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_getTranslationDictString(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDigitalOutputControlMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDigitalOutputControlMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDigitalOutputControlMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDigitalOutputControlMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalOutputControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalOutputControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDigitalOutputControlMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIDigitalOutputControlMode_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIDigitalOutputControlMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDigitalOutputControlMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDigitalOutputControlMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDigitalOutputControlMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDigitalOutputControlMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalOutputControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalOutputControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalOutputControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalOutputControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalOutputControlMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->read(*arg2,arg3); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDigitalOutputControlMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->read(*arg2,arg3); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDigitalOutputControlMode_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDigitalOutputControlMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0;
    { { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDigitalOutputControlMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDigitalOutputControlMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDigitalOutputControlMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDigitalOutputControlMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDigitalOutputControlMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDigitalOutputControlMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDigitalOutputControlMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDigitalOutputControlMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *,std::vector< mvIMPACT::acquire::TDigitalOutputControlMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *,std::vector< mvIMPACT::acquire::TDigitalOutputControlMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *,std::vector< mvIMPACT::acquire::TDigitalOutputControlMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *,std::vector< mvIMPACT::acquire::TDigitalOutputControlMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *,std::vector< mvIMPACT::acquire::TDigitalOutputControlMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *,std::vector< mvIMPACT::acquire::TDigitalOutputControlMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDigitalOutputControlMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDigitalOutputControlMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDigitalOutputControlMode> * const pV = new std::vector<mvIMPACT::acquire::TDigitalOutputControlMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDigitalOutputControlMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDigitalOutputControlMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalOutputControlMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDigitalOutputControlMode> * const pV = new std::vector<mvIMPACT::acquire::TDigitalOutputControlMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDigitalOutputControlMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDigitalOutputControlMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalOutputControlMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDigitalOutputControlMode> * const pV = new std::vector<mvIMPACT::acquire::TDigitalOutputControlMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDigitalOutputControlMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDigitalOutputControlMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalOutputControlMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDigitalOutputControlMode> * const pV = new std::vector<mvIMPACT::acquire::TDigitalOutputControlMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDigitalOutputControlMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDigitalOutputControlMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalOutputControlMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalOutputControlMode_write(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5]; if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDigitalOutputControlMode_write",0,4,argv))) SWIG_fail;
  --argc; if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDigitalOutputControlMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDigitalOutputControlMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDigitalOutputControlMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDigitalOutputControlMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDigitalOutputControlMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDigitalOutputControlMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDigitalOutputControlMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *,mvIMPACT::acquire::TDigitalOutputControlMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *,mvIMPACT::acquire::TDigitalOutputControlMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *,std::vector< mvIMPACT::acquire::TDigitalOutputControlMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *,std::vector< mvIMPACT::acquire::TDigitalOutputControlMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *,std::vector< mvIMPACT::acquire::TDigitalOutputControlMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode > const *,std::vector< mvIMPACT::acquire::TDigitalOutputControlMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIDigitalSignal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIDigitalSignal",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIDigitalSignal__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIDigitalSignal__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIDigitalSignal'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDigitalSignal_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDigitalSignal_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDigitalSignal_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDigitalSignal_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDigitalSignal_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIDigitalSignal_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDigitalSignal_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalSignal)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalSignal)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDigitalSignal_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIDigitalSignal_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIDigitalSignal_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDigitalSignal_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIDigitalSignal_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIDigitalSignal_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDigitalSignal> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalSignal)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalSignal)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalSignal)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalSignal)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalSignal)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TDigitalSignal> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->read(*arg2,arg3,arg4,arg5); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDigitalSignal_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIDigitalSignal_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIDigitalSignal_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIDigitalSignal_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDigitalSignal_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDigitalSignal_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIDigitalSignal_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIDigitalSignal_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIDigitalSignal_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDigitalSignal_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *,std::vector< mvIMPACT::acquire::TDigitalSignal > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *,std::vector< mvIMPACT::acquire::TDigitalSignal > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *,std::vector< mvIMPACT::acquire::TDigitalSignal > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *,std::vector< mvIMPACT::acquire::TDigitalSignal > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *,std::vector< mvIMPACT::acquire::TDigitalSignal > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *,std::vector< mvIMPACT::acquire::TDigitalSignal > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDigitalSignal_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIDigitalSignal_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDigitalSignal> * const pV = new std::vector<mvIMPACT::acquire::TDigitalSignal> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDigitalSignal>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDigitalSignal,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalSignal > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDigitalSignal> * const pV = new std::vector<mvIMPACT::acquire::TDigitalSignal> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDigitalSignal>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDigitalSignal,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalSignal > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDigitalSignal> * const pV = new std::vector<mvIMPACT::acquire::TDigitalSignal> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDigitalSignal>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDigitalSignal,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalSignal > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TDigitalSignal> * const pV = new std::vector<mvIMPACT::acquire::TDigitalSignal> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TDigitalSignal>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TDigitalSignal,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *)arg1)->write((std::vector< mvIMPACT::acquire::TDigitalSignal > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalSignal_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIDigitalSignal_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIDigitalSignal_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIDigitalSignal_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIDigitalSignal_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIDigitalSignal_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIDigitalSignal_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIDigitalSignal_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIDigitalSignal_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIDigitalSignal_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *,mvIMPACT::acquire::TDigitalSignal,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *,mvIMPACT::acquire::TDigitalSignal)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *,std::vector< mvIMPACT::acquire::TDigitalSignal > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *,std::vector< mvIMPACT::acquire::TDigitalSignal > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *,std::vector< mvIMPACT::acquire::TDigitalSignal > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal > const *,std::vector< mvIMPACT::acquire::TDigitalSignal > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIFieldGateMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIFieldGateMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIFieldGateMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIFieldGateMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIFieldGateMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIFieldGateMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIFieldGateMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIFieldGateMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIFieldGateMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIFieldGateMode_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIFieldGateMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIFieldGateMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TFieldGateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TFieldGateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIFieldGateMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIFieldGateMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIFieldGateMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIFieldGateMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIFieldGateMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIFieldGateMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TFieldGateMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TFieldGateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TFieldGateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TFieldGateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TFieldGateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TFieldGateMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TFieldGateMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIFieldGateMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIFieldGateMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIFieldGateMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIFieldGateMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIFieldGateMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIFieldGateMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIFieldGateMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIFieldGateMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIFieldGateMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIFieldGateMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *,std::vector< mvIMPACT::acquire::TFieldGateMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *,std::vector< mvIMPACT::acquire::TFieldGateMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *,std::vector< mvIMPACT::acquire::TFieldGateMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *,std::vector< mvIMPACT::acquire::TFieldGateMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *,std::vector< mvIMPACT::acquire::TFieldGateMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *,std::vector< mvIMPACT::acquire::TFieldGateMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIFieldGateMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIFieldGateMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TFieldGateMode> * const pV = new std::vector<mvIMPACT::acquire::TFieldGateMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TFieldGateMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TFieldGateMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFieldGateMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TFieldGateMode> * const pV = new std::vector<mvIMPACT::acquire::TFieldGateMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TFieldGateMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TFieldGateMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFieldGateMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TFieldGateMode> * const pV = new std::vector<mvIMPACT::acquire::TFieldGateMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TFieldGateMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TFieldGateMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFieldGateMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TFieldGateMode> * const pV = new std::vector<mvIMPACT::acquire::TFieldGateMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TFieldGateMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TFieldGateMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TFieldGateMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIFieldGateMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIFieldGateMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIFieldGateMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIFieldGateMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIFieldGateMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIFieldGateMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIFieldGateMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIFieldGateMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIFieldGateMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *,mvIMPACT::acquire::TFieldGateMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *,mvIMPACT::acquire::TFieldGateMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *,std::vector< mvIMPACT::acquire::TFieldGateMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *,std::vector< mvIMPACT::acquire::TFieldGateMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *,std::vector< mvIMPACT::acquire::TFieldGateMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode > const *,std::vector< mvIMPACT::acquire::TFieldGateMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyII2COperationMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyII2COperationMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyII2COperationMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyII2COperationMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyII2COperationMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyII2COperationMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyII2COperationMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyII2COperationMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyII2COperationMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyII2COperationMode_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyII2COperationMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyII2COperationMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TI2COperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TI2COperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyII2COperationMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyII2COperationMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyII2COperationMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyII2COperationMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyII2COperationMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyII2COperationMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TI2COperationMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TI2COperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TI2COperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TI2COperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TI2COperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TI2COperationMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TI2COperationMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyII2COperationMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyII2COperationMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyII2COperationMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyII2COperationMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyII2COperationMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyII2COperationMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyII2COperationMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyII2COperationMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyII2COperationMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyII2COperationMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *,std::vector< mvIMPACT::acquire::TI2COperationMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *,std::vector< mvIMPACT::acquire::TI2COperationMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *,std::vector< mvIMPACT::acquire::TI2COperationMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *,std::vector< mvIMPACT::acquire::TI2COperationMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *,std::vector< mvIMPACT::acquire::TI2COperationMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *,std::vector< mvIMPACT::acquire::TI2COperationMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyII2COperationMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyII2COperationMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TI2COperationMode> * const pV = new std::vector<mvIMPACT::acquire::TI2COperationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TI2COperationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TI2COperationMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TI2COperationMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TI2COperationMode> * const pV = new std::vector<mvIMPACT::acquire::TI2COperationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TI2COperationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TI2COperationMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TI2COperationMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TI2COperationMode> * const pV = new std::vector<mvIMPACT::acquire::TI2COperationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TI2COperationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TI2COperationMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TI2COperationMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TI2COperationMode> * const pV = new std::vector<mvIMPACT::acquire::TI2COperationMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TI2COperationMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TI2COperationMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TI2COperationMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyII2COperationMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyII2COperationMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyII2COperationMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyII2COperationMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyII2COperationMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyII2COperationMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyII2COperationMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyII2COperationMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *,mvIMPACT::acquire::TI2COperationMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *,mvIMPACT::acquire::TI2COperationMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *,std::vector< mvIMPACT::acquire::TI2COperationMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *,std::vector< mvIMPACT::acquire::TI2COperationMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *,std::vector< mvIMPACT::acquire::TI2COperationMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode > const *,std::vector< mvIMPACT::acquire::TI2COperationMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyII2COperationStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyII2COperationStatus",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyII2COperationStatus__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyII2COperationStatus__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyII2COperationStatus'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyII2COperationStatus_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyII2COperationStatus_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyII2COperationStatus_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyII2COperationStatus_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyII2COperationStatus_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyII2COperationStatus_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyII2COperationStatus_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TI2COperationStatus)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TI2COperationStatus)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyII2COperationStatus_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyII2COperationStatus_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyII2COperationStatus_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyII2COperationStatus_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyII2COperationStatus_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyII2COperationStatus_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TI2COperationStatus> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TI2COperationStatus)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TI2COperationStatus)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TI2COperationStatus)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TI2COperationStatus)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TI2COperationStatus)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->read(*arg2,arg3,arg4); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TI2COperationStatus> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->read(*arg2,arg3,arg4); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyII2COperationStatus_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyII2COperationStatus_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyII2COperationStatus_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyII2COperationStatus_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyII2COperationStatus_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyII2COperationStatus_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyII2COperationStatus_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyII2COperationStatus_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyII2COperationStatus_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyII2COperationStatus_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *,std::vector< mvIMPACT::acquire::TI2COperationStatus > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *,std::vector< mvIMPACT::acquire::TI2COperationStatus > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *,std::vector< mvIMPACT::acquire::TI2COperationStatus > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *,std::vector< mvIMPACT::acquire::TI2COperationStatus > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *,std::vector< mvIMPACT::acquire::TI2COperationStatus > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *,std::vector< mvIMPACT::acquire::TI2COperationStatus > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyII2COperationStatus_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyII2COperationStatus_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TI2COperationStatus> * const pV = new std::vector<mvIMPACT::acquire::TI2COperationStatus> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TI2COperationStatus>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TI2COperationStatus,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->write((std::vector< mvIMPACT::acquire::TI2COperationStatus > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TI2COperationStatus> * const pV = new std::vector<mvIMPACT::acquire::TI2COperationStatus> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TI2COperationStatus>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TI2COperationStatus,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->write((std::vector< mvIMPACT::acquire::TI2COperationStatus > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TI2COperationStatus> * const pV = new std::vector<mvIMPACT::acquire::TI2COperationStatus> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TI2COperationStatus>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TI2COperationStatus,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->write((std::vector< mvIMPACT::acquire::TI2COperationStatus > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TI2COperationStatus> * const pV = new std::vector<mvIMPACT::acquire::TI2COperationStatus> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TI2COperationStatus>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TI2COperationStatus,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *)arg1)->write((std::vector< mvIMPACT::acquire::TI2COperationStatus > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TI2COperationStatus_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyII2COperationStatus_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyII2COperationStatus_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyII2COperationStatus_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyII2COperationStatus_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyII2COperationStatus_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyII2COperationStatus_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyII2COperationStatus_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyII2COperationStatus_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyII2COperationStatus_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *,mvIMPACT::acquire::TI2COperationStatus,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *,mvIMPACT::acquire::TI2COperationStatus)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *,std::vector< mvIMPACT::acquire::TI2COperationStatus > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *,std::vector< mvIMPACT::acquire::TI2COperationStatus > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *,std::vector< mvIMPACT::acquire::TI2COperationStatus > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus > const *,std::vector< mvIMPACT::acquire::TI2COperationStatus > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIInfoSensorColorMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIInfoSensorColorMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIInfoSensorColorMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIInfoSensorColorMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIInfoSensorColorMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIInfoSensorColorMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIInfoSensorColorMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIInfoSensorColorMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIInfoSensorColorMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIInfoSensorColorMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIInfoSensorColorMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIInfoSensorColorMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TInfoSensorColorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TInfoSensorColorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIInfoSensorColorMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIInfoSensorColorMode_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIInfoSensorColorMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIInfoSensorColorMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIInfoSensorColorMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIInfoSensorColorMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TInfoSensorColorMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TInfoSensorColorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TInfoSensorColorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TInfoSensorColorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TInfoSensorColorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TInfoSensorColorMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TInfoSensorColorMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->read(*arg2,arg3,arg4); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIInfoSensorColorMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIInfoSensorColorMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIInfoSensorColorMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIInfoSensorColorMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIInfoSensorColorMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIInfoSensorColorMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIInfoSensorColorMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIInfoSensorColorMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIInfoSensorColorMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIInfoSensorColorMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *,std::vector< mvIMPACT::acquire::TInfoSensorColorMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *,std::vector< mvIMPACT::acquire::TInfoSensorColorMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *,std::vector< mvIMPACT::acquire::TInfoSensorColorMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *,std::vector< mvIMPACT::acquire::TInfoSensorColorMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *,std::vector< mvIMPACT::acquire::TInfoSensorColorMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *,std::vector< mvIMPACT::acquire::TInfoSensorColorMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIInfoSensorColorMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIInfoSensorColorMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TInfoSensorColorMode> * const pV = new std::vector<mvIMPACT::acquire::TInfoSensorColorMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TInfoSensorColorMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TInfoSensorColorMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInfoSensorColorMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TInfoSensorColorMode> * const pV = new std::vector<mvIMPACT::acquire::TInfoSensorColorMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TInfoSensorColorMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TInfoSensorColorMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInfoSensorColorMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TInfoSensorColorMode> * const pV = new std::vector<mvIMPACT::acquire::TInfoSensorColorMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TInfoSensorColorMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TInfoSensorColorMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInfoSensorColorMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TInfoSensorColorMode> * const pV = new std::vector<mvIMPACT::acquire::TInfoSensorColorMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TInfoSensorColorMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TInfoSensorColorMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInfoSensorColorMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorColorMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorColorMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIInfoSensorColorMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIInfoSensorColorMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIInfoSensorColorMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIInfoSensorColorMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIInfoSensorColorMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIInfoSensorColorMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIInfoSensorColorMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIInfoSensorColorMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *,mvIMPACT::acquire::TInfoSensorColorMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *,mvIMPACT::acquire::TInfoSensorColorMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *,std::vector< mvIMPACT::acquire::TInfoSensorColorMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *,std::vector< mvIMPACT::acquire::TInfoSensorColorMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *,std::vector< mvIMPACT::acquire::TInfoSensorColorMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode > const *,std::vector< mvIMPACT::acquire::TInfoSensorColorMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIInfoSensorType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIInfoSensorType",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIInfoSensorType__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIInfoSensorType__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIInfoSensorType'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIInfoSensorType_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIInfoSensorType_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIInfoSensorType_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIInfoSensorType_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIInfoSensorType_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIInfoSensorType_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIInfoSensorType_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TInfoSensorType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TInfoSensorType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIInfoSensorType_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIInfoSensorType_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIInfoSensorType_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIInfoSensorType_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIInfoSensorType_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIInfoSensorType_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TInfoSensorType> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TInfoSensorType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TInfoSensorType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TInfoSensorType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TInfoSensorType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TInfoSensorType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TInfoSensorType> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->read(*arg2,arg3,arg4,arg5); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIInfoSensorType_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIInfoSensorType_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIInfoSensorType_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIInfoSensorType_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIInfoSensorType_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIInfoSensorType_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIInfoSensorType_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIInfoSensorType_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIInfoSensorType_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIInfoSensorType_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *,std::vector< mvIMPACT::acquire::TInfoSensorType > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *,std::vector< mvIMPACT::acquire::TInfoSensorType > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *,std::vector< mvIMPACT::acquire::TInfoSensorType > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *,std::vector< mvIMPACT::acquire::TInfoSensorType > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *,std::vector< mvIMPACT::acquire::TInfoSensorType > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *,std::vector< mvIMPACT::acquire::TInfoSensorType > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIInfoSensorType_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIInfoSensorType_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TInfoSensorType> * const pV = new std::vector<mvIMPACT::acquire::TInfoSensorType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TInfoSensorType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TInfoSensorType,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInfoSensorType > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TInfoSensorType> * const pV = new std::vector<mvIMPACT::acquire::TInfoSensorType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TInfoSensorType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TInfoSensorType,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInfoSensorType > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TInfoSensorType> * const pV = new std::vector<mvIMPACT::acquire::TInfoSensorType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TInfoSensorType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TInfoSensorType,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInfoSensorType > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TInfoSensorType> * const pV = new std::vector<mvIMPACT::acquire::TInfoSensorType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TInfoSensorType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TInfoSensorType,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInfoSensorType > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInfoSensorType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInfoSensorType_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIInfoSensorType_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIInfoSensorType_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIInfoSensorType_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIInfoSensorType_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIInfoSensorType_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIInfoSensorType_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIInfoSensorType_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIInfoSensorType_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *,mvIMPACT::acquire::TInfoSensorType,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *,mvIMPACT::acquire::TInfoSensorType)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *,std::vector< mvIMPACT::acquire::TInfoSensorType > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *,std::vector< mvIMPACT::acquire::TInfoSensorType > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *,std::vector< mvIMPACT::acquire::TInfoSensorType > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType > const *,std::vector< mvIMPACT::acquire::TInfoSensorType > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIInterlacedMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIInterlacedMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIInterlacedMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIInterlacedMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIInterlacedMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIInterlacedMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIInterlacedMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIInterlacedMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIInterlacedMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIInterlacedMode_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIInterlacedMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIInterlacedMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TInterlacedMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TInterlacedMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIInterlacedMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIInterlacedMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIInterlacedMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIInterlacedMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIInterlacedMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIInterlacedMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TInterlacedMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TInterlacedMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TInterlacedMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TInterlacedMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TInterlacedMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TInterlacedMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TInterlacedMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIInterlacedMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIInterlacedMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIInterlacedMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIInterlacedMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIInterlacedMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIInterlacedMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIInterlacedMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIInterlacedMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIInterlacedMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIInterlacedMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *,std::vector< mvIMPACT::acquire::TInterlacedMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *,std::vector< mvIMPACT::acquire::TInterlacedMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *,std::vector< mvIMPACT::acquire::TInterlacedMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *,std::vector< mvIMPACT::acquire::TInterlacedMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *,std::vector< mvIMPACT::acquire::TInterlacedMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *,std::vector< mvIMPACT::acquire::TInterlacedMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIInterlacedMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIInterlacedMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TInterlacedMode> * const pV = new std::vector<mvIMPACT::acquire::TInterlacedMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TInterlacedMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TInterlacedMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInterlacedMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TInterlacedMode> * const pV = new std::vector<mvIMPACT::acquire::TInterlacedMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TInterlacedMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TInterlacedMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInterlacedMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TInterlacedMode> * const pV = new std::vector<mvIMPACT::acquire::TInterlacedMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TInterlacedMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TInterlacedMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInterlacedMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TInterlacedMode> * const pV = new std::vector<mvIMPACT::acquire::TInterlacedMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TInterlacedMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TInterlacedMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TInterlacedMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TInterlacedMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIInterlacedMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIInterlacedMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIInterlacedMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIInterlacedMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIInterlacedMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIInterlacedMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIInterlacedMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIInterlacedMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIInterlacedMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *,mvIMPACT::acquire::TInterlacedMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *,mvIMPACT::acquire::TInterlacedMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *,std::vector< mvIMPACT::acquire::TInterlacedMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *,std::vector< mvIMPACT::acquire::TInterlacedMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *,std::vector< mvIMPACT::acquire::TInterlacedMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode > const *,std::vector< mvIMPACT::acquire::TInterlacedMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyILineCounter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyILineCounter",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyILineCounter__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyILineCounter__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyILineCounter'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyILineCounter_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TLineCounter > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyILineCounter_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TLineCounter > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TLineCounter > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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 *_wrap_PropertyILineCounter_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILineCounter_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyILineCounter_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyILineCounter_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILineCounter_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLineCounter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLineCounter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILineCounter_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyILineCounter_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyILineCounter_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILineCounter_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyILineCounter_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyILineCounter_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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 *_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TLineCounter> (0); arg2 = pV; }
   { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLineCounter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLineCounter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLineCounter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLineCounter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TLineCounter)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TLineCounter> (0); arg2 = pV; }
   { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->read(*arg2,arg3,arg4,arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILineCounter_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyILineCounter_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyILineCounter_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyILineCounter_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyILineCounter_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyILineCounter_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyILineCounter_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyILineCounter_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyILineCounter_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILineCounter_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *,std::vector< mvIMPACT::acquire::TLineCounter > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *,std::vector< mvIMPACT::acquire::TLineCounter > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *,std::vector< mvIMPACT::acquire::TLineCounter > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *,std::vector< mvIMPACT::acquire::TLineCounter > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *,std::vector< mvIMPACT::acquire::TLineCounter > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *,std::vector< mvIMPACT::acquire::TLineCounter > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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 *_wrap_PropertyILineCounter_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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 *_wrap_PropertyILineCounter_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLineCounter> * const pV = new std::vector<mvIMPACT::acquire::TLineCounter> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLineCounter>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLineCounter,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLineCounter > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLineCounter> * const pV = new std::vector<mvIMPACT::acquire::TLineCounter> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLineCounter>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLineCounter,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLineCounter > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLineCounter> * const pV = new std::vector<mvIMPACT::acquire::TLineCounter> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLineCounter>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLineCounter,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLineCounter > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TLineCounter> * const pV = new std::vector<mvIMPACT::acquire::TLineCounter> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TLineCounter>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TLineCounter,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *)arg1)->write((std::vector< mvIMPACT::acquire::TLineCounter > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLineCounter_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyILineCounter_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyILineCounter_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyILineCounter_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyILineCounter_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyILineCounter_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyILineCounter_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyILineCounter_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyILineCounter_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyILineCounter_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *,mvIMPACT::acquire::TLineCounter,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *,mvIMPACT::acquire::TLineCounter)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *,std::vector< mvIMPACT::acquire::TLineCounter > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *,std::vector< mvIMPACT::acquire::TLineCounter > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *,std::vector< mvIMPACT::acquire::TLineCounter > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter > const *,std::vector< mvIMPACT::acquire::TLineCounter > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIMemoryManagerMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIMemoryManagerMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIMemoryManagerMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIMemoryManagerMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIMemoryManagerMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIMemoryManagerMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIMemoryManagerMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIMemoryManagerMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIMemoryManagerMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIMemoryManagerMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIMemoryManagerMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIMemoryManagerMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMemoryManagerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMemoryManagerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIMemoryManagerMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIMemoryManagerMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIMemoryManagerMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIMemoryManagerMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIMemoryManagerMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIMemoryManagerMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TMemoryManagerMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMemoryManagerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMemoryManagerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMemoryManagerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMemoryManagerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMemoryManagerMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TMemoryManagerMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIMemoryManagerMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIMemoryManagerMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIMemoryManagerMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIMemoryManagerMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIMemoryManagerMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIMemoryManagerMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIMemoryManagerMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIMemoryManagerMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIMemoryManagerMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIMemoryManagerMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *,std::vector< mvIMPACT::acquire::TMemoryManagerMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *,std::vector< mvIMPACT::acquire::TMemoryManagerMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *,std::vector< mvIMPACT::acquire::TMemoryManagerMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *,std::vector< mvIMPACT::acquire::TMemoryManagerMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *,std::vector< mvIMPACT::acquire::TMemoryManagerMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *,std::vector< mvIMPACT::acquire::TMemoryManagerMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIMemoryManagerMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIMemoryManagerMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TMemoryManagerMode> * const pV = new std::vector<mvIMPACT::acquire::TMemoryManagerMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TMemoryManagerMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TMemoryManagerMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMemoryManagerMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TMemoryManagerMode> * const pV = new std::vector<mvIMPACT::acquire::TMemoryManagerMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TMemoryManagerMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TMemoryManagerMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMemoryManagerMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TMemoryManagerMode> * const pV = new std::vector<mvIMPACT::acquire::TMemoryManagerMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TMemoryManagerMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TMemoryManagerMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMemoryManagerMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TMemoryManagerMode> * const pV = new std::vector<mvIMPACT::acquire::TMemoryManagerMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TMemoryManagerMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TMemoryManagerMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMemoryManagerMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIMemoryManagerMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIMemoryManagerMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIMemoryManagerMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIMemoryManagerMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIMemoryManagerMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIMemoryManagerMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIMemoryManagerMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIMemoryManagerMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *,mvIMPACT::acquire::TMemoryManagerMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *,mvIMPACT::acquire::TMemoryManagerMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *,std::vector< mvIMPACT::acquire::TMemoryManagerMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *,std::vector< mvIMPACT::acquire::TMemoryManagerMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *,std::vector< mvIMPACT::acquire::TMemoryManagerMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode > const *,std::vector< mvIMPACT::acquire::TMemoryManagerMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIMemoryManagerPoolMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIMemoryManagerPoolMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIMemoryManagerPoolMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIMemoryManagerPoolMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIMemoryManagerPoolMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIMemoryManagerPoolMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIMemoryManagerPoolMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIMemoryManagerPoolMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIMemoryManagerPoolMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIMemoryManagerPoolMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIMemoryManagerPoolMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIMemoryManagerPoolMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMemoryManagerPoolMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMemoryManagerPoolMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIMemoryManagerPoolMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIMemoryManagerPoolMode_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIMemoryManagerPoolMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIMemoryManagerPoolMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIMemoryManagerPoolMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIMemoryManagerPoolMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMemoryManagerPoolMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMemoryManagerPoolMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMemoryManagerPoolMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMemoryManagerPoolMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TMemoryManagerPoolMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->read(*arg2,arg3,arg4); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->read(*arg2,arg3,arg4); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIMemoryManagerPoolMode_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIMemoryManagerPoolMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; {
      { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIMemoryManagerPoolMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIMemoryManagerPoolMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIMemoryManagerPoolMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIMemoryManagerPoolMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIMemoryManagerPoolMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIMemoryManagerPoolMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIMemoryManagerPoolMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIMemoryManagerPoolMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *,std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *,std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *,std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *,std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *,std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *,std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIMemoryManagerPoolMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIMemoryManagerPoolMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode> * const pV = new std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TMemoryManagerPoolMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode> * const pV = new std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TMemoryManagerPoolMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode> * const pV = new std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TMemoryManagerPoolMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode> * const pV = new std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TMemoryManagerPoolMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TMemoryManagerPoolMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMemoryManagerPoolMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIMemoryManagerPoolMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIMemoryManagerPoolMode_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIMemoryManagerPoolMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIMemoryManagerPoolMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIMemoryManagerPoolMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIMemoryManagerPoolMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIMemoryManagerPoolMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIMemoryManagerPoolMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIMemoryManagerPoolMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *,mvIMPACT::acquire::TMemoryManagerPoolMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *,mvIMPACT::acquire::TMemoryManagerPoolMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *,std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *,std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *,std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode > const *,std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIOnBoardMemoryMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIOnBoardMemoryMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIOnBoardMemoryMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIOnBoardMemoryMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIOnBoardMemoryMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIOnBoardMemoryMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIOnBoardMemoryMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIOnBoardMemoryMode_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIOnBoardMemoryMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIOnBoardMemoryMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIOnBoardMemoryMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TOnBoardMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TOnBoardMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIOnBoardMemoryMode_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIOnBoardMemoryMode_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIOnBoardMemoryMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIOnBoardMemoryMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIOnBoardMemoryMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIOnBoardMemoryMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TOnBoardMemoryMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TOnBoardMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TOnBoardMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TOnBoardMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TOnBoardMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TOnBoardMemoryMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TOnBoardMemoryMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIOnBoardMemoryMode_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIOnBoardMemoryMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIOnBoardMemoryMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIOnBoardMemoryMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIOnBoardMemoryMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIOnBoardMemoryMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIOnBoardMemoryMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIOnBoardMemoryMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIOnBoardMemoryMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIOnBoardMemoryMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *,std::vector< mvIMPACT::acquire::TOnBoardMemoryMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *,std::vector< mvIMPACT::acquire::TOnBoardMemoryMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *,std::vector< mvIMPACT::acquire::TOnBoardMemoryMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *,std::vector< mvIMPACT::acquire::TOnBoardMemoryMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *,std::vector< mvIMPACT::acquire::TOnBoardMemoryMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *,std::vector< mvIMPACT::acquire::TOnBoardMemoryMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TOnBoardMemoryMode> * const pV = new std::vector<mvIMPACT::acquire::TOnBoardMemoryMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TOnBoardMemoryMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TOnBoardMemoryMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TOnBoardMemoryMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TOnBoardMemoryMode> * const pV = new std::vector<mvIMPACT::acquire::TOnBoardMemoryMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TOnBoardMemoryMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TOnBoardMemoryMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TOnBoardMemoryMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TOnBoardMemoryMode> * const pV = new std::vector<mvIMPACT::acquire::TOnBoardMemoryMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TOnBoardMemoryMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TOnBoardMemoryMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TOnBoardMemoryMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TOnBoardMemoryMode> * const pV = new std::vector<mvIMPACT::acquire::TOnBoardMemoryMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TOnBoardMemoryMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TOnBoardMemoryMode,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TOnBoardMemoryMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIOnBoardMemoryMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIOnBoardMemoryMode_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIOnBoardMemoryMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIOnBoardMemoryMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIOnBoardMemoryMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIOnBoardMemoryMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIOnBoardMemoryMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIOnBoardMemoryMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIOnBoardMemoryMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *,mvIMPACT::acquire::TOnBoardMemoryMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *,mvIMPACT::acquire::TOnBoardMemoryMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *,std::vector< mvIMPACT::acquire::TOnBoardMemoryMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *,std::vector< mvIMPACT::acquire::TOnBoardMemoryMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *,std::vector< mvIMPACT::acquire::TOnBoardMemoryMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode > const *,std::vector< mvIMPACT::acquire::TOnBoardMemoryMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIPulseStartTrigger__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIPulseStartTrigger",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIPulseStartTrigger__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIPulseStartTrigger__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIPulseStartTrigger'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIPulseStartTrigger_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIPulseStartTrigger_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIPulseStartTrigger_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIPulseStartTrigger_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIPulseStartTrigger_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIPulseStartTrigger_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIPulseStartTrigger_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TPulseStartTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TPulseStartTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIPulseStartTrigger_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIPulseStartTrigger_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIPulseStartTrigger_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIPulseStartTrigger_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIPulseStartTrigger_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIPulseStartTrigger_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TPulseStartTrigger> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TPulseStartTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TPulseStartTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TPulseStartTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TPulseStartTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TPulseStartTrigger)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TPulseStartTrigger> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIPulseStartTrigger_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIPulseStartTrigger_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIPulseStartTrigger_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIPulseStartTrigger_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIPulseStartTrigger_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIPulseStartTrigger_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIPulseStartTrigger_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIPulseStartTrigger_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIPulseStartTrigger_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIPulseStartTrigger_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *,std::vector< mvIMPACT::acquire::TPulseStartTrigger > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *,std::vector< mvIMPACT::acquire::TPulseStartTrigger > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *,std::vector< mvIMPACT::acquire::TPulseStartTrigger > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *,std::vector< mvIMPACT::acquire::TPulseStartTrigger > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *,std::vector< mvIMPACT::acquire::TPulseStartTrigger > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *,std::vector< mvIMPACT::acquire::TPulseStartTrigger > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIPulseStartTrigger_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIPulseStartTrigger_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TPulseStartTrigger> * const pV = new std::vector<mvIMPACT::acquire::TPulseStartTrigger> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TPulseStartTrigger>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TPulseStartTrigger,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPulseStartTrigger > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TPulseStartTrigger> * const pV = new std::vector<mvIMPACT::acquire::TPulseStartTrigger> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TPulseStartTrigger>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TPulseStartTrigger,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPulseStartTrigger > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TPulseStartTrigger> * const pV = new std::vector<mvIMPACT::acquire::TPulseStartTrigger> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TPulseStartTrigger>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TPulseStartTrigger,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPulseStartTrigger > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TPulseStartTrigger> * const pV = new std::vector<mvIMPACT::acquire::TPulseStartTrigger> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TPulseStartTrigger>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TPulseStartTrigger,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *)arg1)->write((std::vector< mvIMPACT::acquire::TPulseStartTrigger > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPulseStartTrigger_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIPulseStartTrigger_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIPulseStartTrigger_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIPulseStartTrigger_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIPulseStartTrigger_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIPulseStartTrigger_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIPulseStartTrigger_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIPulseStartTrigger_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIPulseStartTrigger_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIPulseStartTrigger_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *,mvIMPACT::acquire::TPulseStartTrigger,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *,mvIMPACT::acquire::TPulseStartTrigger)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *,std::vector< mvIMPACT::acquire::TPulseStartTrigger > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *,std::vector< mvIMPACT::acquire::TPulseStartTrigger > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *,std::vector< mvIMPACT::acquire::TPulseStartTrigger > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger > const *,std::vector< mvIMPACT::acquire::TPulseStartTrigger > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIRTCtrlModes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIRTCtrlModes",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIRTCtrlModes__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIRTCtrlModes__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIRTCtrlModes'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIRTCtrlModes_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIRTCtrlModes_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIRTCtrlModes_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIRTCtrlModes_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIRTCtrlModes_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIRTCtrlModes_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIRTCtrlModes_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRTCtrlModes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRTCtrlModes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIRTCtrlModes_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIRTCtrlModes_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIRTCtrlModes_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIRTCtrlModes_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIRTCtrlModes_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIRTCtrlModes_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TRTCtrlModes> (0); arg2 = pV; }
   { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRTCtrlModes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRTCtrlModes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRTCtrlModes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRTCtrlModes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRTCtrlModes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TRTCtrlModes> (0); arg2 = pV; }
   { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->read(*arg2,arg3,arg4,arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIRTCtrlModes_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIRTCtrlModes_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIRTCtrlModes_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIRTCtrlModes_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIRTCtrlModes_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIRTCtrlModes_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIRTCtrlModes_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIRTCtrlModes_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIRTCtrlModes_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIRTCtrlModes_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *,std::vector< mvIMPACT::acquire::TRTCtrlModes > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *,std::vector< mvIMPACT::acquire::TRTCtrlModes > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *,std::vector< mvIMPACT::acquire::TRTCtrlModes > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *,std::vector< mvIMPACT::acquire::TRTCtrlModes > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *,std::vector< mvIMPACT::acquire::TRTCtrlModes > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *,std::vector< mvIMPACT::acquire::TRTCtrlModes > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIRTCtrlModes_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIRTCtrlModes_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TRTCtrlModes> * const pV = new std::vector<mvIMPACT::acquire::TRTCtrlModes> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TRTCtrlModes>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TRTCtrlModes,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRTCtrlModes > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TRTCtrlModes> * const pV = new std::vector<mvIMPACT::acquire::TRTCtrlModes> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TRTCtrlModes>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TRTCtrlModes,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRTCtrlModes > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TRTCtrlModes> * const pV = new std::vector<mvIMPACT::acquire::TRTCtrlModes> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TRTCtrlModes>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TRTCtrlModes,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRTCtrlModes > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TRTCtrlModes> * const pV = new std::vector<mvIMPACT::acquire::TRTCtrlModes> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TRTCtrlModes>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TRTCtrlModes,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRTCtrlModes > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTCtrlModes_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTCtrlModes_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIRTCtrlModes_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIRTCtrlModes_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIRTCtrlModes_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIRTCtrlModes_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIRTCtrlModes_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIRTCtrlModes_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIRTCtrlModes_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIRTCtrlModes_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *,mvIMPACT::acquire::TRTCtrlModes,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *,mvIMPACT::acquire::TRTCtrlModes)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *,std::vector< mvIMPACT::acquire::TRTCtrlModes > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *,std::vector< mvIMPACT::acquire::TRTCtrlModes > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *,std::vector< mvIMPACT::acquire::TRTCtrlModes > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes > const *,std::vector< mvIMPACT::acquire::TRTCtrlModes > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIRTProgOpCodes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIRTProgOpCodes",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIRTProgOpCodes__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIRTProgOpCodes__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIRTProgOpCodes'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIRTProgOpCodes_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIRTProgOpCodes_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIRTProgOpCodes_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIRTProgOpCodes_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIRTProgOpCodes_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIRTProgOpCodes_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIRTProgOpCodes_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRTProgOpCodes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRTProgOpCodes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIRTProgOpCodes_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIRTProgOpCodes_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIRTProgOpCodes_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIRTProgOpCodes_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIRTProgOpCodes_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIRTProgOpCodes_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TRTProgOpCodes> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRTProgOpCodes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRTProgOpCodes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRTProgOpCodes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRTProgOpCodes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TRTProgOpCodes)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TRTProgOpCodes> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->read(*arg2,arg3,arg4,arg5); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIRTProgOpCodes_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIRTProgOpCodes_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIRTProgOpCodes_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIRTProgOpCodes_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIRTProgOpCodes_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIRTProgOpCodes_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIRTProgOpCodes_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIRTProgOpCodes_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIRTProgOpCodes_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIRTProgOpCodes_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *,std::vector< mvIMPACT::acquire::TRTProgOpCodes > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *,std::vector< mvIMPACT::acquire::TRTProgOpCodes > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *,std::vector< mvIMPACT::acquire::TRTProgOpCodes > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *,std::vector< mvIMPACT::acquire::TRTProgOpCodes > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *,std::vector< mvIMPACT::acquire::TRTProgOpCodes > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *,std::vector< mvIMPACT::acquire::TRTProgOpCodes > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIRTProgOpCodes_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIRTProgOpCodes_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TRTProgOpCodes> * const pV = new std::vector<mvIMPACT::acquire::TRTProgOpCodes> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TRTProgOpCodes>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TRTProgOpCodes,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRTProgOpCodes > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TRTProgOpCodes> * const pV = new std::vector<mvIMPACT::acquire::TRTProgOpCodes> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TRTProgOpCodes>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TRTProgOpCodes,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRTProgOpCodes > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TRTProgOpCodes> * const pV = new std::vector<mvIMPACT::acquire::TRTProgOpCodes> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TRTProgOpCodes>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TRTProgOpCodes,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRTProgOpCodes > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TRTProgOpCodes> * const pV = new std::vector<mvIMPACT::acquire::TRTProgOpCodes> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TRTProgOpCodes>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TRTProgOpCodes,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *)arg1)->write((std::vector< mvIMPACT::acquire::TRTProgOpCodes > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRTProgOpCodes_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIRTProgOpCodes_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIRTProgOpCodes_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIRTProgOpCodes_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIRTProgOpCodes_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIRTProgOpCodes_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIRTProgOpCodes_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIRTProgOpCodes_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIRTProgOpCodes_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIRTProgOpCodes_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *,mvIMPACT::acquire::TRTProgOpCodes,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *,mvIMPACT::acquire::TRTProgOpCodes)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *,std::vector< mvIMPACT::acquire::TRTProgOpCodes > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *,std::vector< mvIMPACT::acquire::TRTProgOpCodes > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *,std::vector< mvIMPACT::acquire::TRTProgOpCodes > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes > const *,std::vector< mvIMPACT::acquire::TRTProgOpCodes > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIScanClock__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIScanClock",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIScanClock__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIScanClock__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIScanClock'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIScanClock_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TScanClock > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIScanClock_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TScanClock > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TScanClock > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIScanClock_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIScanClock_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIScanClock_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIScanClock_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIScanClock_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScanClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScanClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIScanClock_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIScanClock_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIScanClock_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIScanClock_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIScanClock_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIScanClock_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TScanClock> (0); arg2 = pV; }  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScanClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScanClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScanClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScanClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScanClock)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TScanClock> (0); arg2 = pV; }  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->read(*arg2,arg3,arg4,arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIScanClock_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIScanClock_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2; return _wrap_PropertyIScanClock_read__SWIG_4(self, argc, argv);}
   check_2: if (argc == 2) { return _wrap_PropertyIScanClock_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIScanClock_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIScanClock_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIScanClock_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIScanClock_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIScanClock_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIScanClock_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *,std::vector< mvIMPACT::acquire::TScanClock > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *,std::vector< mvIMPACT::acquire::TScanClock > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *,std::vector< mvIMPACT::acquire::TScanClock > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *,std::vector< mvIMPACT::acquire::TScanClock > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *,std::vector< mvIMPACT::acquire::TScanClock > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *,std::vector< mvIMPACT::acquire::TScanClock > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIScanClock_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIScanClock_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TScanClock> * const pV = new std::vector<mvIMPACT::acquire::TScanClock> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TScanClock>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TScanClock,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScanClock > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TScanClock> * const pV = new std::vector<mvIMPACT::acquire::TScanClock> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TScanClock>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TScanClock,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScanClock > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TScanClock> * const pV = new std::vector<mvIMPACT::acquire::TScanClock> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TScanClock>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TScanClock,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScanClock > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TScanClock> * const pV = new std::vector<mvIMPACT::acquire::TScanClock> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TScanClock>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TScanClock,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScanClock > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanClock_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanClock_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIScanClock_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIScanClock_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIScanClock_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3; return _wrap_PropertyIScanClock_write__SWIG_2(self, argc, argv);}
   check_3: if (argc == 3) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { {
        int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIScanClock_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIScanClock_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIScanClock_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIScanClock_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *,mvIMPACT::acquire::TScanClock,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *,mvIMPACT::acquire::TScanClock)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *,std::vector< mvIMPACT::acquire::TScanClock > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *,std::vector< mvIMPACT::acquire::TScanClock > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *,std::vector< mvIMPACT::acquire::TScanClock > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock > const *,std::vector< mvIMPACT::acquire::TScanClock > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIScanStandard__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIScanStandard",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIScanStandard__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIScanStandard__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIScanStandard'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIScanStandard_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TScanStandard > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIScanStandard_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TScanStandard > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TScanStandard > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIScanStandard_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIScanStandard_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIScanStandard_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIScanStandard_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIScanStandard_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScanStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScanStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIScanStandard_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIScanStandard_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIScanStandard_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIScanStandard_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIScanStandard_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIScanStandard_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TScanStandard> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScanStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScanStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScanStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScanStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TScanStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TScanStandard> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->read(*arg2,arg3,arg4,arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIScanStandard_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIScanStandard_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIScanStandard_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIScanStandard_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIScanStandard_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIScanStandard_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIScanStandard_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIScanStandard_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIScanStandard_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIScanStandard_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *,std::vector< mvIMPACT::acquire::TScanStandard > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *,std::vector< mvIMPACT::acquire::TScanStandard > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *,std::vector< mvIMPACT::acquire::TScanStandard > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *,std::vector< mvIMPACT::acquire::TScanStandard > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *,std::vector< mvIMPACT::acquire::TScanStandard > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *,std::vector< mvIMPACT::acquire::TScanStandard > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIScanStandard_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIScanStandard_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TScanStandard> * const pV = new std::vector<mvIMPACT::acquire::TScanStandard> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TScanStandard>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TScanStandard,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScanStandard > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TScanStandard> * const pV = new std::vector<mvIMPACT::acquire::TScanStandard> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TScanStandard>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TScanStandard,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScanStandard > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TScanStandard> * const pV = new std::vector<mvIMPACT::acquire::TScanStandard> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TScanStandard>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TScanStandard,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScanStandard > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TScanStandard> * const pV = new std::vector<mvIMPACT::acquire::TScanStandard> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TScanStandard>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TScanStandard,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *)arg1)->write((std::vector< mvIMPACT::acquire::TScanStandard > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TScanStandard_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIScanStandard_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIScanStandard_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIScanStandard_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIScanStandard_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIScanStandard_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIScanStandard_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIScanStandard_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIScanStandard_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIScanStandard_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *,mvIMPACT::acquire::TScanStandard,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *,mvIMPACT::acquire::TScanStandard)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *,std::vector< mvIMPACT::acquire::TScanStandard > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *,std::vector< mvIMPACT::acquire::TScanStandard > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *,std::vector< mvIMPACT::acquire::TScanStandard > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard > const *,std::vector< mvIMPACT::acquire::TScanStandard > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyITriggerMoment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyITriggerMoment",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyITriggerMoment__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyITriggerMoment__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyITriggerMoment'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyITriggerMoment_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyITriggerMoment_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyITriggerMoment_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyITriggerMoment_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyITriggerMoment_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyITriggerMoment_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyITriggerMoment_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TTriggerMoment)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TTriggerMoment)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyITriggerMoment_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyITriggerMoment_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyITriggerMoment_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyITriggerMoment_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyITriggerMoment_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyITriggerMoment_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TTriggerMoment> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TTriggerMoment)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TTriggerMoment)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TTriggerMoment)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TTriggerMoment)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TTriggerMoment)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TTriggerMoment> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->read(*arg2,arg3,arg4,arg5); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyITriggerMoment_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyITriggerMoment_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyITriggerMoment_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyITriggerMoment_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyITriggerMoment_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyITriggerMoment_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyITriggerMoment_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyITriggerMoment_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyITriggerMoment_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyITriggerMoment_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *,std::vector< mvIMPACT::acquire::TTriggerMoment > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *,std::vector< mvIMPACT::acquire::TTriggerMoment > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *,std::vector< mvIMPACT::acquire::TTriggerMoment > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *,std::vector< mvIMPACT::acquire::TTriggerMoment > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *,std::vector< mvIMPACT::acquire::TTriggerMoment > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *,std::vector< mvIMPACT::acquire::TTriggerMoment > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyITriggerMoment_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyITriggerMoment_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TTriggerMoment> * const pV = new std::vector<mvIMPACT::acquire::TTriggerMoment> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TTriggerMoment>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TTriggerMoment,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->write((std::vector< mvIMPACT::acquire::TTriggerMoment > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TTriggerMoment> * const pV = new std::vector<mvIMPACT::acquire::TTriggerMoment> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TTriggerMoment>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TTriggerMoment,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->write((std::vector< mvIMPACT::acquire::TTriggerMoment > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TTriggerMoment> * const pV = new std::vector<mvIMPACT::acquire::TTriggerMoment> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TTriggerMoment>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TTriggerMoment,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->write((std::vector< mvIMPACT::acquire::TTriggerMoment > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TTriggerMoment> * const pV = new std::vector<mvIMPACT::acquire::TTriggerMoment> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TTriggerMoment>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TTriggerMoment,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *)arg1)->write((std::vector< mvIMPACT::acquire::TTriggerMoment > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TTriggerMoment_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyITriggerMoment_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyITriggerMoment_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyITriggerMoment_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyITriggerMoment_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyITriggerMoment_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyITriggerMoment_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyITriggerMoment_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyITriggerMoment_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyITriggerMoment_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *,mvIMPACT::acquire::TTriggerMoment,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *,mvIMPACT::acquire::TTriggerMoment)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *,std::vector< mvIMPACT::acquire::TTriggerMoment > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *,std::vector< mvIMPACT::acquire::TTriggerMoment > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *,std::vector< mvIMPACT::acquire::TTriggerMoment > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment > const *,std::vector< mvIMPACT::acquire::TTriggerMoment > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIVideoStandard__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIVideoStandard",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIVideoStandard__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIVideoStandard__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIVideoStandard'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIVideoStandard_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TVideoStandard > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIVideoStandard_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TVideoStandard > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TVideoStandard > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIVideoStandard_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIVideoStandard_getTranslationDictString",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIVideoStandard_getTranslationDictString__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIVideoStandard_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIVideoStandard_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TVideoStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TVideoStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIVideoStandard_getTranslationDictValue",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIVideoStandard_getTranslationDictValue__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_PropertyIVideoStandard_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIVideoStandard_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)\n"); return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIVideoStandard_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIVideoStandard_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TVideoStandard> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TVideoStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TVideoStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TVideoStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TVideoStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TVideoStandard)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TVideoStandard> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->read(*arg2,arg3,arg4,arg5); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->read(*arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIVideoStandard_read",0,5,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_PropertyIVideoStandard_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; { {
        _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIVideoStandard_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIVideoStandard_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIVideoStandard_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIVideoStandard_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIVideoStandard_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIVideoStandard_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIVideoStandard_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIVideoStandard_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *,std::vector< mvIMPACT::acquire::TVideoStandard > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *,std::vector< mvIMPACT::acquire::TVideoStandard > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *,std::vector< mvIMPACT::acquire::TVideoStandard > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *,std::vector< mvIMPACT::acquire::TVideoStandard > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *,std::vector< mvIMPACT::acquire::TVideoStandard > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *,std::vector< mvIMPACT::acquire::TVideoStandard > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIVideoStandard_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIVideoStandard_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TVideoStandard> * const pV = new std::vector<mvIMPACT::acquire::TVideoStandard> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TVideoStandard>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TVideoStandard,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVideoStandard > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TVideoStandard> * const pV = new std::vector<mvIMPACT::acquire::TVideoStandard> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TVideoStandard>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TVideoStandard,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVideoStandard > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TVideoStandard> * const pV = new std::vector<mvIMPACT::acquire::TVideoStandard> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TVideoStandard>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TVideoStandard,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVideoStandard > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TVideoStandard> * const pV = new std::vector<mvIMPACT::acquire::TVideoStandard> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TVideoStandard>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TVideoStandard,SWIG_POINTER_EXCEPTION) == -1) {
        SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVideoStandard > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVideoStandard_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVideoStandard_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIVideoStandard_write",0,4,argv))) SWIG_fail; --argc; if (argc == 2) {
    int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIVideoStandard_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIVideoStandard_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIVideoStandard_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIVideoStandard_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIVideoStandard_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIVideoStandard_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIVideoStandard_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *,mvIMPACT::acquire::TVideoStandard,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *,mvIMPACT::acquire::TVideoStandard)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *,std::vector< mvIMPACT::acquire::TVideoStandard > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *,std::vector< mvIMPACT::acquire::TVideoStandard > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *,std::vector< mvIMPACT::acquire::TVideoStandard > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard > const *,std::vector< mvIMPACT::acquire::TVideoStandard > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIVirtualDeviceImageType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIVirtualDeviceImageType",0,1,argv))) SWIG_fail; --argc;
  if (argc == 0) { return _wrap_new_PropertyIVirtualDeviceImageType__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIVirtualDeviceImageType__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIVirtualDeviceImageType'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >(mvIMPACT::acquire::HOBJ)\n");
  return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIVirtualDeviceImageType_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIVirtualDeviceImageType_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIVirtualDeviceImageType_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIVirtualDeviceImageType_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIVirtualDeviceImageType_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIVirtualDeviceImageType_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIVirtualDeviceImageType_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TVirtualDeviceImageType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TVirtualDeviceImageType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIVirtualDeviceImageType_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIVirtualDeviceImageType_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIVirtualDeviceImageType_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIVirtualDeviceImageType_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIVirtualDeviceImageType_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIVirtualDeviceImageType_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceImageType> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TVirtualDeviceImageType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TVirtualDeviceImageType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TVirtualDeviceImageType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TVirtualDeviceImageType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TVirtualDeviceImageType)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceImageType> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->read(*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIVirtualDeviceImageType_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIVirtualDeviceImageType_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; {
      { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIVirtualDeviceImageType_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIVirtualDeviceImageType_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIVirtualDeviceImageType_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIVirtualDeviceImageType_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIVirtualDeviceImageType_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIVirtualDeviceImageType_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIVirtualDeviceImageType_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIVirtualDeviceImageType_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *,std::vector< mvIMPACT::acquire::TVirtualDeviceImageType > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *,std::vector< mvIMPACT::acquire::TVirtualDeviceImageType > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *,std::vector< mvIMPACT::acquire::TVirtualDeviceImageType > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *,std::vector< mvIMPACT::acquire::TVirtualDeviceImageType > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *,std::vector< mvIMPACT::acquire::TVirtualDeviceImageType > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *,std::vector< mvIMPACT::acquire::TVirtualDeviceImageType > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIVirtualDeviceImageType_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIVirtualDeviceImageType_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TVirtualDeviceImageType> * const pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceImageType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TVirtualDeviceImageType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TVirtualDeviceImageType,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVirtualDeviceImageType > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TVirtualDeviceImageType> * const pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceImageType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TVirtualDeviceImageType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TVirtualDeviceImageType,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVirtualDeviceImageType > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TVirtualDeviceImageType> * const pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceImageType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TVirtualDeviceImageType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TVirtualDeviceImageType,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVirtualDeviceImageType > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TVirtualDeviceImageType> * const pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceImageType> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TVirtualDeviceImageType>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TVirtualDeviceImageType,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVirtualDeviceImageType > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceImageType_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceImageType_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIVirtualDeviceImageType_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIVirtualDeviceImageType_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIVirtualDeviceImageType_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIVirtualDeviceImageType_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIVirtualDeviceImageType_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIVirtualDeviceImageType_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIVirtualDeviceImageType_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIVirtualDeviceImageType_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *,mvIMPACT::acquire::TVirtualDeviceImageType,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *,mvIMPACT::acquire::TVirtualDeviceImageType)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *,std::vector< mvIMPACT::acquire::TVirtualDeviceImageType > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *,std::vector< mvIMPACT::acquire::TVirtualDeviceImageType > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *,std::vector< mvIMPACT::acquire::TVirtualDeviceImageType > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType > const *,std::vector< mvIMPACT::acquire::TVirtualDeviceImageType > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_PropertyIVirtualDeviceTestMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *result = 0 ;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *)new mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PropertyIVirtualDeviceTestMode",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_PropertyIVirtualDeviceTestMode__SWIG_0(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_PropertyIVirtualDeviceTestMode__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_PropertyIVirtualDeviceTestMode'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >()\n"
  "    mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >(mvIMPACT::acquire::HOBJ)\n"); return NULL; }
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 > > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIVirtualDeviceTestMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIVirtualDeviceTestMode_getTranslationDict" "', argument " "2"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > > * >(argp2); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->getTranslationDict(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIVirtualDeviceTestMode_getTranslationDictString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->getTranslationDictString(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->getTranslationDictString(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_getTranslationDictString(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIVirtualDeviceTestMode_getTranslationDictString",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIVirtualDeviceTestMode_getTranslationDictString__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIVirtualDeviceTestMode_getTranslationDictString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIVirtualDeviceTestMode_getTranslationDictString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *,int)\n"
  "    getTranslationDictString(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_getTranslationDictValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TVirtualDeviceTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->getTranslationDictValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_getTranslationDictValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TVirtualDeviceTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->getTranslationDictValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_getTranslationDictValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIVirtualDeviceTestMode_getTranslationDictValue",0,2,argv))) SWIG_fail;
  --argc; if (argc == 1) { return _wrap_PropertyIVirtualDeviceTestMode_getTranslationDictValue__SWIG_1(self, argc, argv);} 
  if (argc == 2) { return _wrap_PropertyIVirtualDeviceTestMode_getTranslationDictValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIVirtualDeviceTestMode_getTranslationDictValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *,int)\n"
  "    getTranslationDictValue(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)\n");
  return NULL; }
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 > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 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);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 ); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertyIVirtualDeviceTestMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'");  }
   if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PropertyIVirtualDeviceTestMode_getTranslationDictStrings" "', argument " "2"" of type '" "std::vector< std::string > &""'"); }
   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->getTranslationDictStrings(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->getTranslationDictValues(*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TVirtualDeviceTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->read(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TVirtualDeviceTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->read(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TVirtualDeviceTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->getMaxValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TVirtualDeviceTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->getMinValue(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TVirtualDeviceTestMode)((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->getStepWidth(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->read(*arg2,arg3,arg4); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_read__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_read__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode> (0);
    arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->read(*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_read__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->read(*arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_read__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->read(*arg2,arg3,arg4); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_read__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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 > *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> * const 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        ((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->read(*arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_read(PyObject *self, PyObject *args) { int argc; PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIVirtualDeviceTestMode_read",0,5,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_PropertyIVirtualDeviceTestMode_read__SWIG_1(self, argc, argv);}  if (argc == 2) { int _v = 0; {
      { _v = PyList_Check(argv[1]);  } }  if (!_v) goto check_2;
    return _wrap_PropertyIVirtualDeviceTestMode_read__SWIG_4(self, argc, argv);}  check_2: if (argc == 2) {
    return _wrap_PropertyIVirtualDeviceTestMode_read__SWIG_0(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIVirtualDeviceTestMode_read__SWIG_3(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIVirtualDeviceTestMode_read__SWIG_7(self, argc, argv);}  if (argc == 4) { int _v = 0; { {
        int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } }  if (!_v) goto check_6;
    return _wrap_PropertyIVirtualDeviceTestMode_read__SWIG_2(self, argc, argv);}  check_6: if (argc == 4) {
    return _wrap_PropertyIVirtualDeviceTestMode_read__SWIG_6(self, argc, argv);}  if (argc == 5) {
    return _wrap_PropertyIVirtualDeviceTestMode_read__SWIG_5(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIVirtualDeviceTestMode_read'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *,std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode > &,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *,std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode > &,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *,std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode > &)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *,std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode > &,bool,int,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *,std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode > &,bool,int)\n"
  "    read(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *,std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode > &,bool)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->write(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIVirtualDeviceTestMode_write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->write(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_PropertyIVirtualDeviceTestMode_write__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode> * const pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TVirtualDeviceTestMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_write__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode> * const pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TVirtualDeviceTestMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  arg2 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode > const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_write__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode> * const pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TVirtualDeviceTestMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode > const &)*arg2,arg3,arg4); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_write__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[1])) { PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; } 
    const int size = PySequence_Length(swig_obj[1]);
    std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode> * const pV = new std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode> (size);
    for (int i = 0; i < size; i++) { PyObject * const o = PySequence_GetItem(swig_obj[1],i);
      std::vector<mvIMPACT::acquire::TVirtualDeviceTestMode>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_mvIMPACT__acquire__TVirtualDeviceTestMode,SWIG_POINTER_EXCEPTION) == -1)
      { SWIG_fail; }  (*pV)[i] = *pItem;  Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > *) &((mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *)arg1)->write((std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode > const &)*arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TVirtualDeviceTestMode_t, 0 |  0 );
  { }  { if (arg2) delete arg2; }  return resultobj; fail: { if (arg2) delete arg2; }  return NULL; }
SWIGINTERN PyObject *_wrap_PropertyIVirtualDeviceTestMode_write(PyObject *self, PyObject *args) { int argc; PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"PropertyIVirtualDeviceTestMode_write",0,4,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { { _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_1;
    return _wrap_PropertyIVirtualDeviceTestMode_write__SWIG_3(self, argc, argv);}  check_1: if (argc == 2) {
    return _wrap_PropertyIVirtualDeviceTestMode_write__SWIG_1(self, argc, argv);}  if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_3; { { int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_3;
    return _wrap_PropertyIVirtualDeviceTestMode_write__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) { int _v = 0; { {
        _v = PySequence_Check(argv[1]);  } }  if (!_v) goto check_4; { { int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res); } }  if (!_v) goto check_4;
    return _wrap_PropertyIVirtualDeviceTestMode_write__SWIG_5(self, argc, argv);}  check_4: if (argc == 3) {
    return _wrap_PropertyIVirtualDeviceTestMode_write__SWIG_0(self, argc, argv);}  if (argc == 4) {
    return _wrap_PropertyIVirtualDeviceTestMode_write__SWIG_4(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PropertyIVirtualDeviceTestMode_write'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *,mvIMPACT::acquire::TVirtualDeviceTestMode,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *,mvIMPACT::acquire::TVirtualDeviceTestMode)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *,std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode > const &,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *,std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode > const &)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *,std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode > const &,bool,int)\n"
  "    write(mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode > const *,std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode > const &,bool)\n");
  return NULL; }
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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::ImageMemoryManager *)new mvIMPACT::acquire::ImageMemoryManager(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::InfoBlueDevice *)new mvIMPACT::acquire::InfoBlueDevice(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::InfoBlueCOUGAR *)new mvIMPACT::acquire::InfoBlueCOUGAR(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_deviceBootloaderVersion_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_deviceBootloaderVersion_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)->deviceBootloaderVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InfoBlueCOUGAR_deviceRFSVersion_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_deviceRFSVersion_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)->deviceRFSVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InfoBlueCOUGAR_deviceKernelVersion_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_deviceKernelVersion_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)->deviceKernelVersion); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  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_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InfoBlueCOUGAR_deviceStatus_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_deviceStatus_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)->deviceStatus); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InfoBlueCOUGAR_deviceStatusMessage_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::PropertyS *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_deviceStatusMessage_get" "', argument " "1"" of type '" "mvIMPACT::acquire::InfoBlueCOUGAR *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::InfoBlueCOUGAR * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->deviceStatusMessage); 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_InfoBlueCOUGAR_deviceSensorRevision_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_deviceSensorRevision_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)->deviceSensorRevision); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_InfoBlueCOUGAR_clientConnectionState_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::PropertyI *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_clientConnectionState_get" "', argument " "1"" of type '" "mvIMPACT::acquire::InfoBlueCOUGAR *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::InfoBlueCOUGAR * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->clientConnectionState); 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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::InfoBlueFOX *)new mvIMPACT::acquire::InfoBlueFOX(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::DigitalInput const *)arg1)->get(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::DigitalInput const *)arg1)->getDescription(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)(arg1)->flip(); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::DigitalOutput const *)arg1)->get(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalOutput_isWriteable(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_isWriteable" "', argument " "1"" of type '" "mvIMPACT::acquire::DigitalOutput const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::DigitalOutput const *)arg1)->isWriteable(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DigitalOutput_setOutput(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_setOutput" "', argument " "1"" of type '" "mvIMPACT::acquire::DigitalOutput *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::DigitalOutput * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        (arg1)->set(); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        (arg1)->reset(); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::DigitalOutput const *)arg1)->getDescription(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::SyncOutput const *)arg1)->getDescription(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::RTCtrProgram *)new mvIMPACT::acquire::RTCtrProgram((mvIMPACT::acquire::RTCtrProgram const &)*arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { (arg1)->setProgramSize(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::RTCtrProgram const *)arg1)->getProgramSize(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::RTCtrProgramStep *)((mvIMPACT::acquire::RTCtrProgram const *)arg1)->programStep(arg2); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->load(); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->save(); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::PulseStartConfiguration const *)arg1)->number(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::PulseStartConfiguration *)((mvIMPACT::acquire::IOSubSystem const *)arg1)->getPulseStartConfiguration(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::IOSubSystem const *)arg1)->getPulseStartConfigurationCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::RTCtrProgram *)((mvIMPACT::acquire::IOSubSystem const *)arg1)->getRTCtrProgram(arg2); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::IOSubSystem const *)arg1)->RTCtrProgramCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::IOSubSystem const *)arg1)->getInputCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::IOSubSystem const *)arg1)->readInputRegister(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::DigitalInput *)((mvIMPACT::acquire::IOSubSystem const *)arg1)->input(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::DigitalOutput *)((mvIMPACT::acquire::IOSubSystem const *)arg1)->output(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::IOSubSystem const *)arg1)->getOutputCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::IOSubSystem const *)arg1)->readOutputRegister(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { (arg1)->writeOutputRegister(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystem_writeOutputRegister__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { (arg1)->writeOutputRegister(arg2); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystem_writeOutputRegister(PyObject *self, PyObject *args) { int argc; PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"IOSubSystem_writeOutputRegister",0,3,argv))) SWIG_fail; --argc; if (argc == 2) {
    return _wrap_IOSubSystem_writeOutputRegister__SWIG_1(self, argc, argv);}  if (argc == 3) {
    return _wrap_IOSubSystem_writeOutputRegister__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IOSubSystem_writeOutputRegister'.\n"
  "  Possible C/C++ prototypes are:\n" "    writeOutputRegister(mvIMPACT::acquire::IOSubSystem *,unsigned int,unsigned int)\n"
  "    writeOutputRegister(mvIMPACT::acquire::IOSubSystem *,unsigned int)\n"); return NULL; }
SWIGINTERN PyObject *IOSubSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::IOSubSystemBlueFOX *)new mvIMPACT::acquire::IOSubSystemBlueFOX(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::IOSubSystemBlueFOX const *)arg1)->readInputRegisterAtomic(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::IOSubSystemBlueFOX const *)arg1)->readOutputRegisterAtomic(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { (arg1)->writeOutputRegister(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystemBlueFOX_writeOutputRegister__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { (arg1)->writeOutputRegister(arg2); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystemBlueFOX_writeOutputRegister(PyObject *self, PyObject *args) { int argc; PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"IOSubSystemBlueFOX_writeOutputRegister",0,3,argv))) SWIG_fail; --argc;
  if (argc == 2) { return _wrap_IOSubSystemBlueFOX_writeOutputRegister__SWIG_1(self, argc, argv);}  if (argc == 3) {
    return _wrap_IOSubSystemBlueFOX_writeOutputRegister__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IOSubSystemBlueFOX_writeOutputRegister'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    writeOutputRegister(mvIMPACT::acquire::IOSubSystemBlueFOX *,unsigned int,unsigned int)\n"
  "    writeOutputRegister(mvIMPACT::acquire::IOSubSystemBlueFOX *,unsigned int)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystemBlueFOX_writeOutputRegisterAtomic__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        (arg1)->writeOutputRegisterAtomic(arg2,arg3); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystemBlueFOX_writeOutputRegisterAtomic__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        (arg1)->writeOutputRegisterAtomic(arg2); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystemBlueFOX_writeOutputRegisterAtomic(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"IOSubSystemBlueFOX_writeOutputRegisterAtomic",0,3,argv))) SWIG_fail; --argc;
  if (argc == 2) { return _wrap_IOSubSystemBlueFOX_writeOutputRegisterAtomic__SWIG_1(self, argc, argv);}  if (argc == 3) {
    return _wrap_IOSubSystemBlueFOX_writeOutputRegisterAtomic__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IOSubSystemBlueFOX_writeOutputRegisterAtomic'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    writeOutputRegisterAtomic(mvIMPACT::acquire::IOSubSystemBlueFOX *,unsigned int,unsigned int)\n"
  "    writeOutputRegisterAtomic(mvIMPACT::acquire::IOSubSystemBlueFOX *,unsigned int)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::IOSubSystemCommon *)new mvIMPACT::acquire::IOSubSystemCommon(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { (arg1)->writeOutputRegister(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystemCommon_writeOutputRegister__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { (arg1)->writeOutputRegister(arg2); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystemCommon_writeOutputRegister(PyObject *self, PyObject *args) { int argc; PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"IOSubSystemCommon_writeOutputRegister",0,3,argv))) SWIG_fail; --argc;
  if (argc == 2) { return _wrap_IOSubSystemCommon_writeOutputRegister__SWIG_1(self, argc, argv);}  if (argc == 3) {
    return _wrap_IOSubSystemCommon_writeOutputRegister__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IOSubSystemCommon_writeOutputRegister'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    writeOutputRegister(mvIMPACT::acquire::IOSubSystemCommon *,unsigned int,unsigned int)\n"
  "    writeOutputRegister(mvIMPACT::acquire::IOSubSystemCommon *,unsigned int)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *)new mvIMPACT::acquire::OutputSignalGeneratorBlueDevice(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try {
        result = (mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *)new mvIMPACT::acquire::OutputSignalGeneratorBlueDevice((mvIMPACT::acquire::OutputSignalGeneratorBlueDevice const &)*arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  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) { return _wrap_new_OutputSignalGeneratorBlueDevice__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OutputSignalGeneratorBlueDevice'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::OutputSignalGeneratorBlueDevice(mvIMPACT::acquire::Device *)\n"
  "    mvIMPACT::acquire::OutputSignalGeneratorBlueDevice(mvIMPACT::acquire::OutputSignalGeneratorBlueDevice const &)\n");
  return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->undefineSignal(arg2); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::OutputSignalGeneratorBlueDevice const *)arg1)->canCreateExposeActiveSignal(arg2); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::OutputSignalGeneratorBlueDevice const *)arg1)->canInvertSignal(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDeviceDigitalOutputMode)((mvIMPACT::acquire::OutputSignalGeneratorBlueDevice const *)arg1)->getOutputMode(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::OutputSignalGeneratorBlueDevice const *)arg1)->isOutputModeActive(arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::OutputSignalGeneratorBlueDevice const *)arg1)->isSignalInverted(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorBlueDevice_setOutputMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->setOutputMode(arg2,arg3,arg4); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorBlueDevice_setOutputMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->setOutputMode(arg2,arg3); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorBlueDevice_setOutputMode(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"OutputSignalGeneratorBlueDevice_setOutputMode",0,4,argv))) SWIG_fail; --argc;
  if (argc == 3) { return _wrap_OutputSignalGeneratorBlueDevice_setOutputMode__SWIG_1(self, argc, argv);}  if (argc == 4) {
    return _wrap_OutputSignalGeneratorBlueDevice_setOutputMode__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'OutputSignalGeneratorBlueDevice_setOutputMode'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    setOutputMode(mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *,mvIMPACT::acquire::DigitalOutput *,mvIMPACT::acquire::TDeviceDigitalOutputMode,bool)\n"
  "    setOutputMode(mvIMPACT::acquire::OutputSignalGeneratorBlueDevice *,mvIMPACT::acquire::DigitalOutput *,mvIMPACT::acquire::TDeviceDigitalOutputMode)\n");
  return NULL; }
SWIGINTERN PyObject *OutputSignalGeneratorBlueDevice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::IOSubSystemFrameGrabber *)new mvIMPACT::acquire::IOSubSystemFrameGrabber(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::IOSubSystemFrameGrabber const *)arg1)->getHDOutputCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::SyncOutput *)((mvIMPACT::acquire::IOSubSystemFrameGrabber const *)arg1)->HDOutput(arg2); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::IOSubSystemFrameGrabber const *)arg1)->getVDOutputCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::SyncOutput *)((mvIMPACT::acquire::IOSubSystemFrameGrabber const *)arg1)->VDOutput(arg2); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *)new mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try {
        result = (mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *)new mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber((mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const &)*arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  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) { return _wrap_new_OutputSignalGeneratorFrameGrabber__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_OutputSignalGeneratorFrameGrabber'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber(mvIMPACT::acquire::Device *)\n"
  "    mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber(mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const &)\n");
  return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_definePulse__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->definePulse(arg2,arg3,arg4,arg5,arg6); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_definePulse__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->definePulse(arg2,arg3,arg4,arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_definePulse(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[7];
  if (!(argc = SWIG_Python_UnpackTuple(args,"OutputSignalGeneratorFrameGrabber_definePulse",0,6,argv))) SWIG_fail; --argc;
  if (argc == 5) { return _wrap_OutputSignalGeneratorFrameGrabber_definePulse__SWIG_1(self, argc, argv);}  if (argc == 6) {
    return _wrap_OutputSignalGeneratorFrameGrabber_definePulse__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'OutputSignalGeneratorFrameGrabber_definePulse'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    definePulse(mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *,mvIMPACT::acquire::DigitalOutput *,int,int,int,mvIMPACT::acquire::PulseStartConfiguration *)\n"
  "    definePulse(mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *,mvIMPACT::acquire::DigitalOutput *,int,int,int)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_definePulseSequence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[3])) {
      PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; }  const int size = PySequence_Length(swig_obj[3]);
    std::vector<int> * const pV = new std::vector<int> (size); for (int i = 0; i < size; i++) {
      PyObject * const o = PySequence_GetItem(swig_obj[3],i); std::vector<int>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_int,SWIG_POINTER_EXCEPTION) == -1) { SWIG_fail; }  (*pV)[i] = *pItem; 
      Py_DECREF(o); }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->definePulseSequence(arg2,arg3,(std::vector< int > const &)*arg4,arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); { }  { if (arg4) delete arg4; }  return resultobj; fail: {
    if (arg4) delete arg4; }  return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_definePulseSequence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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 > *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 (!PySequence_Check(swig_obj[3])) {
      PyErr_SetString(PyExc_ValueError,"Expected a sequence."); SWIG_fail; }  const int size = PySequence_Length(swig_obj[3]);
    std::vector<int> * const pV = new std::vector<int> (size); for (int i = 0; i < size; i++) {
      PyObject * const o = PySequence_GetItem(swig_obj[3],i); std::vector<int>::value_type* pItem;
      if (SWIG_ConvertPtr(o, (void**)&pItem, SWIGTYPE_p_int,SWIG_POINTER_EXCEPTION) == -1) { SWIG_fail; }  (*pV)[i] = *pItem; 
      Py_DECREF(o); }  arg4 = pV; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->definePulseSequence(arg2,arg3,(std::vector< int > const &)*arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); { }  { if (arg4) delete arg4; }  return resultobj; fail: {
    if (arg4) delete arg4; }  return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_definePulseSequence(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[6];
  if (!(argc = SWIG_Python_UnpackTuple(args,"OutputSignalGeneratorFrameGrabber_definePulseSequence",0,5,argv))) SWIG_fail;
  --argc; if (argc == 4) { return _wrap_OutputSignalGeneratorFrameGrabber_definePulseSequence__SWIG_1(self, argc, argv);} 
  if (argc == 5) { return _wrap_OutputSignalGeneratorFrameGrabber_definePulseSequence__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'OutputSignalGeneratorFrameGrabber_definePulseSequence'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    definePulseSequence(mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *,mvIMPACT::acquire::DigitalOutput *,int,std::vector< int > const &,mvIMPACT::acquire::PulseStartConfiguration *)\n"
  "    definePulseSequence(mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *,mvIMPACT::acquire::DigitalOutput *,int,std::vector< int > const &)\n");
  return NULL; }
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 ;
  std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > > *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_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OutputSignalGeneratorFrameGrabber_getValidSignalsForPassThroughModes" "', argument " "3"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > > &""'");  }
   if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OutputSignalGeneratorFrameGrabber_getValidSignalsForPassThroughModes" "', argument " "3"" of type '" "std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > > &""'"); }
   arg3 = reinterpret_cast< std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > > * >(argp3); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const *)arg1)->getValidSignalsForPassThroughModes(arg2,*arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const *)arg1)->getValidPassThroughSignalCount(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalSignal)((mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const *)arg1)->getValidPassThroughSignalValue(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TDigitalSignal)((mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const *)arg1)->getValidPassThroughSignalValue(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalValue(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalValue",0,3,argv))) SWIG_fail;
  --argc; if (argc == 2) {
    return _wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalValue__SWIG_1(self, argc, argv);}  if (argc == 3) {
    return _wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalValue__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getValidPassThroughSignalValue(mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const *,mvIMPACT::acquire::DigitalOutput *,int)\n"
  "    getValidPassThroughSignalValue(mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const *,mvIMPACT::acquire::DigitalOutput *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const *)arg1)->getValidPassThroughSignalString(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const *)arg1)->getValidPassThroughSignalString(arg2); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalString(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalString",0,3,argv))) SWIG_fail;
  --argc; if (argc == 2) {
    return _wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalString__SWIG_1(self, argc, argv);}  if (argc == 3) {
    return _wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalString__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalString'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    getValidPassThroughSignalString(mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const *,mvIMPACT::acquire::DigitalOutput *,int)\n"
  "    getValidPassThroughSignalString(mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber const *,mvIMPACT::acquire::DigitalOutput *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_definePassThroughSignal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->definePassThroughSignal(arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_definePassThroughSignal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->definePassThroughSignal(arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_OutputSignalGeneratorFrameGrabber_definePassThroughSignal__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->definePassThroughSignal(arg2,(std::string const &)*arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->definePassThroughSignal(arg2,(std::string const &)*arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[5];
  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) { return _wrap_OutputSignalGeneratorFrameGrabber_definePassThroughSignal__SWIG_3(self, argc, argv);} 
  if (argc == 4) { int _v = 0; { { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } } 
    if (!_v) goto check_3; return _wrap_OutputSignalGeneratorFrameGrabber_definePassThroughSignal__SWIG_0(self, argc, argv);} 
  check_3: if (argc == 4) { return _wrap_OutputSignalGeneratorFrameGrabber_definePassThroughSignal__SWIG_2(self, argc, argv);} 
  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'OutputSignalGeneratorFrameGrabber_definePassThroughSignal'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    definePassThroughSignal(mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *,mvIMPACT::acquire::DigitalOutput *,mvIMPACT::acquire::TDigitalSignal,bool)\n"
  "    definePassThroughSignal(mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *,mvIMPACT::acquire::DigitalOutput *,mvIMPACT::acquire::TDigitalSignal)\n"
  "    definePassThroughSignal(mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *,mvIMPACT::acquire::DigitalOutput *,std::string const &,bool)\n"
  "    definePassThroughSignal(mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber *,mvIMPACT::acquire::DigitalOutput *,std::string const &)\n");
  return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->undefineSignal(arg2); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->defineLineScanPulse(arg2,arg3,arg4,arg5,arg6,arg7); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_IOSubSystemBlueCOUGAR(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::IOSubSystemBlueCOUGAR *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_IOSubSystemBlueCOUGAR" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::IOSubSystemBlueCOUGAR *)new mvIMPACT::acquire::IOSubSystemBlueCOUGAR(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemBlueCOUGAR, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_IOSubSystemBlueCOUGAR_digitalInputThreshold_mV_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystemBlueCOUGAR *arg1 = (mvIMPACT::acquire::IOSubSystemBlueCOUGAR *) 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__IOSubSystemBlueCOUGAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IOSubSystemBlueCOUGAR_digitalInputThreshold_mV_get" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystemBlueCOUGAR *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystemBlueCOUGAR * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI *)& ((arg1)->digitalInputThreshold_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_delete_IOSubSystemBlueCOUGAR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::IOSubSystemBlueCOUGAR *arg1 = (mvIMPACT::acquire::IOSubSystemBlueCOUGAR *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemBlueCOUGAR, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IOSubSystemBlueCOUGAR" "', argument " "1"" of type '" "mvIMPACT::acquire::IOSubSystemBlueCOUGAR *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::IOSubSystemBlueCOUGAR * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *IOSubSystemBlueCOUGAR_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__IOSubSystemBlueCOUGAR, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

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

SWIGINTERN PyObject *_wrap_new_Connector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Connector *)new mvIMPACT::acquire::Connector(arg1,(std::string const &)*arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::Connector *)new mvIMPACT::acquire::Connector(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_Connector",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_Connector__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_Connector__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Connector'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::Connector(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::Connector(mvIMPACT::acquire::Device *)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::BasicDeviceSettingsWithAOI *)new mvIMPACT::acquire::BasicDeviceSettingsWithAOI(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::BasicDeviceSettingsWithAOI *)new mvIMPACT::acquire::BasicDeviceSettingsWithAOI(arg1); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_BasicDeviceSettingsWithAOI",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_BasicDeviceSettingsWithAOI__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_BasicDeviceSettingsWithAOI__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BasicDeviceSettingsWithAOI'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::BasicDeviceSettingsWithAOI(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::BasicDeviceSettingsWithAOI(mvIMPACT::acquire::Device *)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraSettingsBase *)new mvIMPACT::acquire::CameraSettingsBase(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraSettingsBase *)new mvIMPACT::acquire::CameraSettingsBase(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_CameraSettingsBase",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_CameraSettingsBase__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_CameraSettingsBase__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CameraSettingsBase'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::CameraSettingsBase(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::CameraSettingsBase(mvIMPACT::acquire::Device *)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraSettingsVirtualDevice *)new mvIMPACT::acquire::CameraSettingsVirtualDevice(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraSettingsVirtualDevice *)new mvIMPACT::acquire::CameraSettingsVirtualDevice(arg1); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_CameraSettingsVirtualDevice",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_CameraSettingsVirtualDevice__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_CameraSettingsVirtualDevice__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CameraSettingsVirtualDevice'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::CameraSettingsVirtualDevice(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::CameraSettingsVirtualDevice(mvIMPACT::acquire::Device *)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraSettingsV4L2Device *)new mvIMPACT::acquire::CameraSettingsV4L2Device(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraSettingsV4L2Device *)new mvIMPACT::acquire::CameraSettingsV4L2Device(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_CameraSettingsV4L2Device",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_CameraSettingsV4L2Device__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_CameraSettingsV4L2Device__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CameraSettingsV4L2Device'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::CameraSettingsV4L2Device(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::CameraSettingsV4L2Device(mvIMPACT::acquire::Device *)\n"); return NULL; }
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::ComponentIterator 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::CameraSettingsV4L2Device const *)arg1)->getCustomFeatureIterator(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::ComponentIterator(static_cast< const mvIMPACT::acquire::ComponentIterator& >(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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::AutoControlParameters const *)arg1)->isAvailable(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraSettingsBlueDevice *)new mvIMPACT::acquire::CameraSettingsBlueDevice(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraSettingsBlueDevice *)new mvIMPACT::acquire::CameraSettingsBlueDevice(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_CameraSettingsBlueDevice",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_CameraSettingsBlueDevice__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_CameraSettingsBlueDevice__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CameraSettingsBlueDevice'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::CameraSettingsBlueDevice(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::CameraSettingsBlueDevice(mvIMPACT::acquire::Device *)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::AutoControlParameters *) &(arg1)->getAutoControlParameters(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::HDRControl *)new mvIMPACT::acquire::HDRControl((mvIMPACT::acquire::HDRControl const &)*arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)((mvIMPACT::acquire::HDRControl const *)arg1)->isAvailable(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::HDRKneePoint *) &((mvIMPACT::acquire::HDRControl const *)arg1)->getHDRKneePoint(arg2); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraSettingsBlueFOX *)new mvIMPACT::acquire::CameraSettingsBlueFOX(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraSettingsBlueFOX *)new mvIMPACT::acquire::CameraSettingsBlueFOX(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_CameraSettingsBlueFOX",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_CameraSettingsBlueFOX__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_CameraSettingsBlueFOX__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CameraSettingsBlueFOX'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::CameraSettingsBlueFOX(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::CameraSettingsBlueFOX(mvIMPACT::acquire::Device *)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::HDRControl *) &(arg1)->getHDRControl(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraSettingsBlueCOUGAR *)new mvIMPACT::acquire::CameraSettingsBlueCOUGAR(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraSettingsBlueCOUGAR *)new mvIMPACT::acquire::CameraSettingsBlueCOUGAR(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_CameraSettingsBlueCOUGAR",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_CameraSettingsBlueCOUGAR__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_CameraSettingsBlueCOUGAR__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CameraSettingsBlueCOUGAR'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::CameraSettingsBlueCOUGAR(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::CameraSettingsBlueCOUGAR(mvIMPACT::acquire::Device *)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::CameraSettingsBlueCOUGAR const *)arg1)->getTriggerControlCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TriggerControl *)((mvIMPACT::acquire::CameraSettingsBlueCOUGAR const *)arg1)->triggerControl(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TriggerControl *)((mvIMPACT::acquire::CameraSettingsBlueCOUGAR const *)arg1)->triggerControl((std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[3]; 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) { return _wrap_CameraSettingsBlueCOUGAR_triggerControl__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CameraSettingsBlueCOUGAR_triggerControl'.\n"
  "  Possible C/C++ prototypes are:\n" "    triggerControl(mvIMPACT::acquire::CameraSettingsBlueCOUGAR const *,unsigned int)\n"
  "    triggerControl(mvIMPACT::acquire::CameraSettingsBlueCOUGAR const *,std::string const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::HDRControl *) &(arg1)->getHDRControl(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *CameraSettingsBlueCOUGAR_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraSettingsFrameGrabber *)new mvIMPACT::acquire::CameraSettingsFrameGrabber(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraSettingsFrameGrabber *)new mvIMPACT::acquire::CameraSettingsFrameGrabber(arg1); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_CameraSettingsFrameGrabber",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_CameraSettingsFrameGrabber__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_CameraSettingsFrameGrabber__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CameraSettingsFrameGrabber'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::CameraSettingsFrameGrabber(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::CameraSettingsFrameGrabber(mvIMPACT::acquire::Device *)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::CameraSettingsFrameGrabber const *)arg1)->getTriggerControlCount(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TriggerControl *)((mvIMPACT::acquire::CameraSettingsFrameGrabber const *)arg1)->triggerControl(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::TriggerControl *)((mvIMPACT::acquire::CameraSettingsFrameGrabber const *)arg1)->triggerControl((std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[3];
  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) { return _wrap_CameraSettingsFrameGrabber_triggerControl__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CameraSettingsFrameGrabber_triggerControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    triggerControl(mvIMPACT::acquire::CameraSettingsFrameGrabber const *,unsigned int)\n"
  "    triggerControl(mvIMPACT::acquire::CameraSettingsFrameGrabber const *,std::string const &)\n"); return NULL; }
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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::CameraDescriptionBase const *)arg1)->getClassName(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::CameraDescriptionBase const *)arg1)->copyDescription((std::string const &)*arg2); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::CameraDescriptionBase const *)arg1)->exportDescription(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)((mvIMPACT::acquire::CameraDescriptionBase const *)arg1)->importDescription(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraDescriptionManager *)new mvIMPACT::acquire::CameraDescriptionManager(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraDescriptionManager *)new mvIMPACT::acquire::CameraDescriptionManager((mvIMPACT::acquire::CameraDescriptionManager const &)*arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  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) { return _wrap_new_CameraDescriptionManager__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CameraDescriptionManager'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::CameraDescriptionManager(mvIMPACT::acquire::Device *)\n"
  "    mvIMPACT::acquire::CameraDescriptionManager(mvIMPACT::acquire::CameraDescriptionManager const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->getCLCameraDescriptionCount(); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraDescriptionCameraLink *)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->cameraDescriptionCameraLink(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraDescriptionCameraLink *)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->cameraDescriptionCameraLink((std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[3];
  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) { return _wrap_CameraDescriptionManager_cameraDescriptionCameraLink__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CameraDescriptionManager_cameraDescriptionCameraLink'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    cameraDescriptionCameraLink(mvIMPACT::acquire::CameraDescriptionManager const *,unsigned int)\n"
  "    cameraDescriptionCameraLink(mvIMPACT::acquire::CameraDescriptionManager const *,std::string const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->getSDICameraDescriptionCount(); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraDescriptionSDI *)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->cameraDescriptionSDI(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraDescriptionSDI *)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->cameraDescriptionSDI((std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[3];
  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) { return _wrap_CameraDescriptionManager_cameraDescriptionSDI__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CameraDescriptionManager_cameraDescriptionSDI'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    cameraDescriptionSDI(mvIMPACT::acquire::CameraDescriptionManager const *,unsigned int)\n"
  "    cameraDescriptionSDI(mvIMPACT::acquire::CameraDescriptionManager const *,std::string const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->getDigitalCameraDescriptionCount(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraDescriptionDigital *)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->cameraDescriptionDigital(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraDescriptionDigital *)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->cameraDescriptionDigital((std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[3];
  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) { return _wrap_CameraDescriptionManager_cameraDescriptionDigital__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CameraDescriptionManager_cameraDescriptionDigital'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    cameraDescriptionDigital(mvIMPACT::acquire::CameraDescriptionManager const *,unsigned int)\n"
  "    cameraDescriptionDigital(mvIMPACT::acquire::CameraDescriptionManager const *,std::string const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->getStandardCameraDescriptionCount(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraDescriptionStandard *)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->cameraDescriptionStandard(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraDescriptionStandard *)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->cameraDescriptionStandard((std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[3];
  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) { return _wrap_CameraDescriptionManager_cameraDescriptionStandard__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CameraDescriptionManager_cameraDescriptionStandard'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    cameraDescriptionStandard(mvIMPACT::acquire::CameraDescriptionManager const *,unsigned int)\n"
  "    cameraDescriptionStandard(mvIMPACT::acquire::CameraDescriptionManager const *,std::string const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->getNonStandardCameraDescriptionCount(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraDescriptionNonStandard *)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->cameraDescriptionNonStandard(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::CameraDescriptionNonStandard *)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->cameraDescriptionNonStandard((std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc;
  PyObject *argv[3];
  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) { return _wrap_CameraDescriptionManager_cameraDescriptionNonStandard__SWIG_1(self, argc, argv);} 
  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CameraDescriptionManager_cameraDescriptionNonStandard'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    cameraDescriptionNonStandard(mvIMPACT::acquire::CameraDescriptionManager const *,unsigned int)\n"
  "    cameraDescriptionNonStandard(mvIMPACT::acquire::CameraDescriptionManager const *,std::string const &)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (unsigned int)((mvIMPACT::acquire::CameraDescriptionManager const *)arg1)->getTotalCameraDescriptionCount(); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::I2CControl *)new mvIMPACT::acquire::I2CControl(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { result = (arg1)->I2CRead(arg2,arg3,arg4,arg5); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { (arg1)->I2CWrite(arg2,arg3,arg4,(std::string const &)*arg5); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::MotorFocusControl *)new mvIMPACT::acquire::MotorFocusControl(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::DigitalIOMeasurementControl *)new mvIMPACT::acquire::DigitalIOMeasurementControl(arg1); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::SettingsBlueFOX *)new mvIMPACT::acquire::SettingsBlueFOX(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::SettingsBlueFOX *)new mvIMPACT::acquire::SettingsBlueFOX(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_SettingsBlueFOX",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_SettingsBlueFOX__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_SettingsBlueFOX__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettingsBlueFOX'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::SettingsBlueFOX(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::SettingsBlueFOX(mvIMPACT::acquire::Device *)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::SettingsFrameGrabber *)new mvIMPACT::acquire::SettingsFrameGrabber(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::SettingsFrameGrabber *)new mvIMPACT::acquire::SettingsFrameGrabber(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_SettingsFrameGrabber",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_SettingsFrameGrabber__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_SettingsFrameGrabber__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SettingsFrameGrabber'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::SettingsFrameGrabber(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::SettingsFrameGrabber(mvIMPACT::acquire::Device *)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::SystemBlueFOX *)new mvIMPACT::acquire::SystemBlueFOX(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::SystemV4L2 *)new mvIMPACT::acquire::SystemV4L2(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_new_DeviceControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::DeviceControl *)new mvIMPACT::acquire::GenICam::DeviceControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::DeviceControl *)new mvIMPACT::acquire::GenICam::DeviceControl(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_DeviceControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_DeviceControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_DeviceControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DeviceControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::DeviceControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::DeviceControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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::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_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::PropertyI64 *)& ((arg1)->mvDeviceTemperatureUpperLimit); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_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::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_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::PropertyI64 *)& ((arg1)->mvDeviceTemperatureLowerLimit); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::ImageFormatControl *)new mvIMPACT::acquire::GenICam::ImageFormatControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::ImageFormatControl *)new mvIMPACT::acquire::GenICam::ImageFormatControl(arg1); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ImageFormatControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_ImageFormatControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_ImageFormatControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ImageFormatControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::ImageFormatControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::ImageFormatControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::AcquisitionControl *)new mvIMPACT::acquire::GenICam::AcquisitionControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::AcquisitionControl *)new mvIMPACT::acquire::GenICam::AcquisitionControl(arg1); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_AcquisitionControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_AcquisitionControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_AcquisitionControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AcquisitionControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::AcquisitionControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::AcquisitionControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_t, 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_int64_t_t, 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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::AnalogControl *)new mvIMPACT::acquire::GenICam::AnalogControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::AnalogControl *)new mvIMPACT::acquire::GenICam::AnalogControl(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_AnalogControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_AnalogControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_AnalogControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AnalogControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::AnalogControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::AnalogControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::LUTControl *)new mvIMPACT::acquire::GenICam::LUTControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::LUTControl *)new mvIMPACT::acquire::GenICam::LUTControl(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_LUTControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_LUTControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_LUTControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LUTControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::LUTControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::LUTControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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_int64_t_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_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::ColorTransformationControl *)new mvIMPACT::acquire::GenICam::ColorTransformationControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::ColorTransformationControl *)new mvIMPACT::acquire::GenICam::ColorTransformationControl(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ColorTransformationControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_ColorTransformationControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_ColorTransformationControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ColorTransformationControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::ColorTransformationControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::ColorTransformationControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::DigitalIOControl *)new mvIMPACT::acquire::GenICam::DigitalIOControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::DigitalIOControl *)new mvIMPACT::acquire::GenICam::DigitalIOControl(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_DigitalIOControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_DigitalIOControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_DigitalIOControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DigitalIOControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::DigitalIOControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::DigitalIOControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *)new mvIMPACT::acquire::GenICam::CounterAndTimerControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::CounterAndTimerControl *)new mvIMPACT::acquire::GenICam::CounterAndTimerControl(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_CounterAndTimerControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_CounterAndTimerControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_CounterAndTimerControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CounterAndTimerControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::CounterAndTimerControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::CounterAndTimerControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::EncoderControl *)new mvIMPACT::acquire::GenICam::EncoderControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::EncoderControl *)new mvIMPACT::acquire::GenICam::EncoderControl(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_EncoderControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_EncoderControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_EncoderControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EncoderControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::EncoderControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::EncoderControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::LogicBlockControl *)new mvIMPACT::acquire::GenICam::LogicBlockControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::LogicBlockControl *)new mvIMPACT::acquire::GenICam::LogicBlockControl(arg1); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_LogicBlockControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_LogicBlockControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_LogicBlockControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LogicBlockControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::LogicBlockControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::LogicBlockControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::SoftwareSignalControl *)new mvIMPACT::acquire::GenICam::SoftwareSignalControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::SoftwareSignalControl *)new mvIMPACT::acquire::GenICam::SoftwareSignalControl(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_SoftwareSignalControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_SoftwareSignalControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_SoftwareSignalControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SoftwareSignalControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::SoftwareSignalControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::SoftwareSignalControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::ActionControl *)new mvIMPACT::acquire::GenICam::ActionControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::ActionControl *)new mvIMPACT::acquire::GenICam::ActionControl(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ActionControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_ActionControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_ActionControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ActionControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::ActionControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::ActionControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::EventControl *)new mvIMPACT::acquire::GenICam::EventControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::EventControl *)new mvIMPACT::acquire::GenICam::EventControl(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_EventControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_EventControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_EventControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EventControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::EventControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::EventControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::UserSetControl *)new mvIMPACT::acquire::GenICam::UserSetControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::UserSetControl *)new mvIMPACT::acquire::GenICam::UserSetControl(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_UserSetControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_UserSetControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_UserSetControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UserSetControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::UserSetControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::UserSetControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_t, 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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::SequencerControl *)new mvIMPACT::acquire::GenICam::SequencerControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::SequencerControl *)new mvIMPACT::acquire::GenICam::SequencerControl(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_SequencerControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_SequencerControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_SequencerControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SequencerControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::SequencerControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::SequencerControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *)new mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl *)new mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_mvDefectivePixelCorrectionControl",0,2,argv))) SWIG_fail; --argc;
  if (argc == 1) { return _wrap_new_mvDefectivePixelCorrectionControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_mvDefectivePixelCorrectionControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_mvDefectivePixelCorrectionControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl(mvIMPACT::acquire::Device *)\n"); 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_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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,(char*)"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_FileAccessControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::FileAccessControl *)new mvIMPACT::acquire::GenICam::FileAccessControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::FileAccessControl *)new mvIMPACT::acquire::GenICam::FileAccessControl(arg1); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_FileAccessControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_FileAccessControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_FileAccessControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FileAccessControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::FileAccessControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::FileAccessControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::SourceControl *)new mvIMPACT::acquire::GenICam::SourceControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::SourceControl *)new mvIMPACT::acquire::GenICam::SourceControl(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_SourceControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_SourceControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_SourceControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SourceControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::SourceControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::SourceControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::TransferControl *)new mvIMPACT::acquire::GenICam::TransferControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::TransferControl *)new mvIMPACT::acquire::GenICam::TransferControl(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_TransferControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_TransferControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_TransferControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TransferControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::TransferControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::TransferControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::Scan3dControl *)new mvIMPACT::acquire::GenICam::Scan3dControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::Scan3dControl *)new mvIMPACT::acquire::GenICam::Scan3dControl(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_Scan3dControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_Scan3dControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_Scan3dControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Scan3dControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::Scan3dControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::Scan3dControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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_LightControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::LightControl *)new mvIMPACT::acquire::GenICam::LightControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::LightControl *)new mvIMPACT::acquire::GenICam::LightControl(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_LightControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_LightControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_LightControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LightControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::LightControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::LightControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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_ChunkDataControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::ChunkDataControl *)new mvIMPACT::acquire::GenICam::ChunkDataControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::ChunkDataControl *)new mvIMPACT::acquire::GenICam::ChunkDataControl(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ChunkDataControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_ChunkDataControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_ChunkDataControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ChunkDataControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::ChunkDataControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::ChunkDataControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::TestControl *)new mvIMPACT::acquire::GenICam::TestControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::TestControl *)new mvIMPACT::acquire::GenICam::TestControl(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_TestControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_TestControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_TestControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TestControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::TestControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::TestControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::TransportLayerControl *)new mvIMPACT::acquire::GenICam::TransportLayerControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::TransportLayerControl *)new mvIMPACT::acquire::GenICam::TransportLayerControl(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_TransportLayerControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_TransportLayerControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_TransportLayerControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TransportLayerControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::TransportLayerControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::TransportLayerControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_t, 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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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::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_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::PropertyI64 *)& ((arg1)->ptpEnable); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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::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_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::PropertyIBoolean *)& ((arg1)->gevGVCPExtendedStatusCodesSelector);
    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_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetEffectivePayloadPacketsPerImage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::int64_type arg1 ; mvIMPACT::acquire::int64_type arg2 ; bool arg3 ; void *argp1 ;
  int res1 = 0 ; void *argp2 ; int res2 = 0 ; bool val3 ; int ecode3 = 0 ; mvIMPACT::acquire::int64_type result;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage" "', argument " "1"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage" "', argument " "1"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp1); arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp; }  }  { res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetEffectivePayloadPacketsPerImage(arg1,arg2,arg3); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::int64_type(static_cast< const mvIMPACT::acquire::int64_type& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetEffectivePayloadPacketsPerImage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::int64_type arg1 ; mvIMPACT::acquire::int64_type arg2 ; void *argp1 ;
  int res1 = 0 ; void *argp2 ; int res2 = 0 ; mvIMPACT::acquire::int64_type result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int64_t,  0  | 0); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage" "', argument " "1"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage" "', argument " "1"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp1); arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp; }  }  { res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetEffectivePayloadPacketsPerImage(arg1,arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::int64_type(static_cast< const mvIMPACT::acquire::int64_type& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetEffectivePayloadPacketsPerImage__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  mvIMPACT::acquire::int64_type arg2 ; bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; bool val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::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); {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t,  0  | 0); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::GenICam::TransportLayerControl const *)arg1)->gevGetEffectivePayloadPacketsPerImage(arg2,arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::int64_type(static_cast< const mvIMPACT::acquire::int64_type& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetEffectivePayloadPacketsPerImage__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  mvIMPACT::acquire::int64_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ;
  mvIMPACT::acquire::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); {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t,  0  | 0); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetEffectivePayloadPacketsPerImage" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::GenICam::TransportLayerControl const *)arg1)->gevGetEffectivePayloadPacketsPerImage(arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::int64_type(static_cast< const mvIMPACT::acquire::int64_type& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetEffectivePayloadPacketsPerImage(PyObject *self, PyObject *args) {
  int argc; PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"TransportLayerControl_gevGetEffectivePayloadPacketsPerImage",0,3,argv))) SWIG_fail;
  --argc; if (argc == 2) { int _v = 0; { int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_int64_t, 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_1;
    return _wrap_TransportLayerControl_gevGetEffectivePayloadPacketsPerImage__SWIG_1(self, argc, argv);}  check_1:
  if (argc == 2) { return _wrap_TransportLayerControl_gevGetEffectivePayloadPacketsPerImage__SWIG_3(self, argc, argv);} 
  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;
    return _wrap_TransportLayerControl_gevGetEffectivePayloadPacketsPerImage__SWIG_2(self, argc, argv);}  check_3:
  if (argc == 3) { return _wrap_TransportLayerControl_gevGetEffectivePayloadPacketsPerImage__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'TransportLayerControl_gevGetEffectivePayloadPacketsPerImage'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    gevGetEffectivePayloadPacketsPerImage(mvIMPACT::acquire::int64_type const,mvIMPACT::acquire::int64_type const,bool const)\n"
  "    gevGetEffectivePayloadPacketsPerImage(mvIMPACT::acquire::int64_type const,mvIMPACT::acquire::int64_type const)\n"
  "    gevGetEffectivePayloadPacketsPerImage(mvIMPACT::acquire::GenICam::TransportLayerControl const *,mvIMPACT::acquire::int64_type const,bool const)\n"
  "    gevGetEffectivePayloadPacketsPerImage(mvIMPACT::acquire::GenICam::TransportLayerControl const *,mvIMPACT::acquire::int64_type const)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetEffectiveBytesPerImage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::int64_type arg1 ; mvIMPACT::acquire::int64_type arg2 ; bool arg3 ; void *argp1 ;
  int res1 = 0 ; void *argp2 ; int res2 = 0 ; bool val3 ; int ecode3 = 0 ; mvIMPACT::acquire::int64_type result;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevGetEffectiveBytesPerImage" "', argument " "1"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetEffectiveBytesPerImage" "', argument " "1"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp1); arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp; }  }  { res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransportLayerControl_gevGetEffectiveBytesPerImage" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetEffectiveBytesPerImage" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetEffectiveBytesPerImage(arg1,arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::int64_type(static_cast< const mvIMPACT::acquire::int64_type& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetEffectiveBytesPerImage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::int64_type arg1 ; mvIMPACT::acquire::int64_type arg2 ; void *argp1 ;
  int res1 = 0 ; void *argp2 ; int res2 = 0 ; mvIMPACT::acquire::int64_type result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int64_t,  0  | 0); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportLayerControl_gevGetEffectiveBytesPerImage" "', argument " "1"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetEffectiveBytesPerImage" "', argument " "1"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp1); arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp; }  }  { res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransportLayerControl_gevGetEffectiveBytesPerImage" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetEffectiveBytesPerImage" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetEffectiveBytesPerImage(arg1,arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::int64_type(static_cast< const mvIMPACT::acquire::int64_type& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetEffectiveBytesPerImage__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  mvIMPACT::acquire::int64_type arg2 ; bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; bool val3 ;
  int ecode3 = 0 ; mvIMPACT::acquire::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); {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t,  0  | 0); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransportLayerControl_gevGetEffectiveBytesPerImage" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetEffectiveBytesPerImage" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::GenICam::TransportLayerControl const *)arg1)->gevGetEffectiveBytesPerImage(arg2,arg3); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::int64_type(static_cast< const mvIMPACT::acquire::int64_type& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetEffectiveBytesPerImage__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  mvIMPACT::acquire::int64_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ;
  mvIMPACT::acquire::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); {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t,  0  | 0); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransportLayerControl_gevGetEffectiveBytesPerImage" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetEffectiveBytesPerImage" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::GenICam::TransportLayerControl const *)arg1)->gevGetEffectiveBytesPerImage(arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::int64_type(static_cast< const mvIMPACT::acquire::int64_type& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetEffectiveBytesPerImage(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"TransportLayerControl_gevGetEffectiveBytesPerImage",0,3,argv))) SWIG_fail; --argc;
  if (argc == 2) { int _v = 0; { int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_int64_t, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_1; return _wrap_TransportLayerControl_gevGetEffectiveBytesPerImage__SWIG_1(self, argc, argv);}  check_1:
  if (argc == 2) { return _wrap_TransportLayerControl_gevGetEffectiveBytesPerImage__SWIG_3(self, argc, argv);}  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;
    return _wrap_TransportLayerControl_gevGetEffectiveBytesPerImage__SWIG_2(self, argc, argv);}  check_3: if (argc == 3) {
    return _wrap_TransportLayerControl_gevGetEffectiveBytesPerImage__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'TransportLayerControl_gevGetEffectiveBytesPerImage'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    gevGetEffectiveBytesPerImage(mvIMPACT::acquire::int64_type const,mvIMPACT::acquire::int64_type const,bool const)\n"
  "    gevGetEffectiveBytesPerImage(mvIMPACT::acquire::int64_type const,mvIMPACT::acquire::int64_type const)\n"
  "    gevGetEffectiveBytesPerImage(mvIMPACT::acquire::GenICam::TransportLayerControl const *,mvIMPACT::acquire::int64_type const,bool const)\n"
  "    gevGetEffectiveBytesPerImage(mvIMPACT::acquire::GenICam::TransportLayerControl const *,mvIMPACT::acquire::int64_type const)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetResultingBandwidth__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; double arg1 ; mvIMPACT::acquire::int64_type arg2 ; mvIMPACT::acquire::int64_type arg3 ; bool arg4 ;
  double val1 ; int ecode1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 ; int res3 = 0 ; bool val4 ; int ecode4 = 0 ;
  mvIMPACT::acquire::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); { res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  { res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "3"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "3"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp3); arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp; }  }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetResultingBandwidth(arg1,arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::int64_type(static_cast< const mvIMPACT::acquire::int64_type& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetResultingBandwidth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; double arg1 ; mvIMPACT::acquire::int64_type arg2 ; mvIMPACT::acquire::int64_type arg3 ; double val1 ;
  int ecode1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 ; int res3 = 0 ; mvIMPACT::acquire::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); { res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  { res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "3"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "3"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp3); arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp; }  }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetResultingBandwidth(arg1,arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::int64_type(static_cast< const mvIMPACT::acquire::int64_type& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetResultingBandwidth__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  double arg2 ; mvIMPACT::acquire::int64_type arg3 ; bool arg4 ; void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ;
  void *argp3 ; int res3 = 0 ; bool val4 ; int ecode4 = 0 ; mvIMPACT::acquire::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); { res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "3"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "3"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp3); arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp; }  }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::GenICam::TransportLayerControl const *)arg1)->gevGetResultingBandwidth(arg2,arg3,arg4); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::int64_type(static_cast< const mvIMPACT::acquire::int64_type& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetResultingBandwidth__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  double arg2 ; mvIMPACT::acquire::int64_type arg3 ; void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ;
  void *argp3 ; int res3 = 0 ; mvIMPACT::acquire::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); { res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "3"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetResultingBandwidth" "', argument " "3"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp3); arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp; }  }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::GenICam::TransportLayerControl const *)arg1)->gevGetResultingBandwidth(arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::int64_type(static_cast< const mvIMPACT::acquire::int64_type& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetResultingBandwidth(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5];
  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;
    return _wrap_TransportLayerControl_gevGetResultingBandwidth__SWIG_3(self, argc, argv);}  check_1: if (argc == 3) {
    return _wrap_TransportLayerControl_gevGetResultingBandwidth__SWIG_1(self, argc, argv);}  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;
    return _wrap_TransportLayerControl_gevGetResultingBandwidth__SWIG_2(self, argc, argv);}  check_3: if (argc == 4) {
    return _wrap_TransportLayerControl_gevGetResultingBandwidth__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'TransportLayerControl_gevGetResultingBandwidth'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    gevGetResultingBandwidth(double const,mvIMPACT::acquire::int64_type const,mvIMPACT::acquire::int64_type const,bool const)\n"
  "    gevGetResultingBandwidth(double const,mvIMPACT::acquire::int64_type const,mvIMPACT::acquire::int64_type const)\n"
  "    gevGetResultingBandwidth(mvIMPACT::acquire::GenICam::TransportLayerControl const *,double const,mvIMPACT::acquire::int64_type const,bool const)\n"
  "    gevGetResultingBandwidth(mvIMPACT::acquire::GenICam::TransportLayerControl const *,double const,mvIMPACT::acquire::int64_type const)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetResultingPacketDelay__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; double arg1 ; mvIMPACT::acquire::int64_type arg2 ; mvIMPACT::acquire::int64_type arg3 ;
  mvIMPACT::acquire::int64_type arg4 ; mvIMPACT::acquire::int64_type arg5 ; bool arg6 ; double val1 ; int ecode1 = 0 ;
  void *argp2 ; int res2 = 0 ; void *argp3 ; int res3 = 0 ; void *argp4 ; int res4 = 0 ; void *argp5 ; int res5 = 0 ;
  bool val6 ; int ecode6 = 0 ; mvIMPACT::acquire::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); { res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  { res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "3"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "3"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp3); arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp; }  }  { res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "4"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "4"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp4); arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp; }  }  { res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "5"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "5"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp5); arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp; }  }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetResultingPacketDelay(arg1,arg2,arg3,arg4,arg5,arg6); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::int64_type(static_cast< const mvIMPACT::acquire::int64_type& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetResultingPacketDelay__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; double arg1 ; mvIMPACT::acquire::int64_type arg2 ; mvIMPACT::acquire::int64_type arg3 ;
  mvIMPACT::acquire::int64_type arg4 ; mvIMPACT::acquire::int64_type arg5 ; double val1 ; int ecode1 = 0 ; void *argp2 ;
  int res2 = 0 ; void *argp3 ; int res3 = 0 ; void *argp4 ; int res4 = 0 ; void *argp5 ; int res5 = 0 ;
  mvIMPACT::acquire::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); { res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  { res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "3"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "3"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp3); arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp; }  }  { res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "4"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "4"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp4); arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp; }  }  { res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "5"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "5"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp5); arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp; }  }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = mvIMPACT::acquire::GenICam::TransportLayerControl::gevGetResultingPacketDelay(arg1,arg2,arg3,arg4,arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::int64_type(static_cast< const mvIMPACT::acquire::int64_type& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetResultingPacketDelay__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  double arg2 ; mvIMPACT::acquire::int64_type arg3 ; mvIMPACT::acquire::int64_type arg4 ; mvIMPACT::acquire::int64_type arg5 ;
  bool arg6 ; void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ; void *argp3 ; int res3 = 0 ; void *argp4 ;
  int res4 = 0 ; void *argp5 ; int res5 = 0 ; bool val6 ; int ecode6 = 0 ; mvIMPACT::acquire::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); { res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "3"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "3"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp3); arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp; }  }  { res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "4"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "4"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp4); arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp; }  }  { res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "5"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "5"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp5); arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp; }  }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::GenICam::TransportLayerControl const *)arg1)->gevGetResultingPacketDelay(arg2,arg3,arg4,arg5,arg6); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::int64_type(static_cast< const mvIMPACT::acquire::int64_type& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetResultingPacketDelay__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::TransportLayerControl *arg1 = (mvIMPACT::acquire::GenICam::TransportLayerControl *) 0 ;
  double arg2 ; mvIMPACT::acquire::int64_type arg3 ; mvIMPACT::acquire::int64_type arg4 ; mvIMPACT::acquire::int64_type arg5 ;
  void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ; void *argp3 ; int res3 = 0 ; void *argp4 ; int res4 = 0 ;
  void *argp5 ; int res5 = 0 ; mvIMPACT::acquire::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); { res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "3"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "3"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp3); arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp; }  }  { res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "4"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "4"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp4); arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp; }  }  { res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "5"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransportLayerControl_gevGetResultingPacketDelay" "', argument " "5"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp5); arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp; }  }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = ((mvIMPACT::acquire::GenICam::TransportLayerControl const *)arg1)->gevGetResultingPacketDelay(arg2,arg3,arg4,arg5); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::int64_type(static_cast< const mvIMPACT::acquire::int64_type& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_TransportLayerControl_gevGetResultingPacketDelay(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[7];
  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;
    return _wrap_TransportLayerControl_gevGetResultingPacketDelay__SWIG_3(self, argc, argv);}  check_1: if (argc == 5) {
    return _wrap_TransportLayerControl_gevGetResultingPacketDelay__SWIG_1(self, argc, argv);}  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;
    return _wrap_TransportLayerControl_gevGetResultingPacketDelay__SWIG_2(self, argc, argv);}  check_3: if (argc == 6) {
    return _wrap_TransportLayerControl_gevGetResultingPacketDelay__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'TransportLayerControl_gevGetResultingPacketDelay'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    gevGetResultingPacketDelay(double const,mvIMPACT::acquire::int64_type const,mvIMPACT::acquire::int64_type const,mvIMPACT::acquire::int64_type const,mvIMPACT::acquire::int64_type const,bool const)\n"
  "    gevGetResultingPacketDelay(double const,mvIMPACT::acquire::int64_type const,mvIMPACT::acquire::int64_type const,mvIMPACT::acquire::int64_type const,mvIMPACT::acquire::int64_type const)\n"
  "    gevGetResultingPacketDelay(mvIMPACT::acquire::GenICam::TransportLayerControl const *,double const,mvIMPACT::acquire::int64_type const,mvIMPACT::acquire::int64_type const,mvIMPACT::acquire::int64_type const,bool const)\n"
  "    gevGetResultingPacketDelay(mvIMPACT::acquire::GenICam::TransportLayerControl const *,double const,mvIMPACT::acquire::int64_type const,mvIMPACT::acquire::int64_type const,mvIMPACT::acquire::int64_type const)\n");
  return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *)new mvIMPACT::acquire::GenICam::mvSerialInterfaceControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::mvSerialInterfaceControl *)new mvIMPACT::acquire::GenICam::mvSerialInterfaceControl(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_mvSerialInterfaceControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_mvSerialInterfaceControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_mvSerialInterfaceControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_mvSerialInterfaceControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::mvSerialInterfaceControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::mvSerialInterfaceControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *)new mvIMPACT::acquire::GenICam::mvI2cInterfaceControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::mvI2cInterfaceControl *)new mvIMPACT::acquire::GenICam::mvI2cInterfaceControl(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_mvI2cInterfaceControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_mvI2cInterfaceControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_mvI2cInterfaceControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_mvI2cInterfaceControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::mvI2cInterfaceControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::mvI2cInterfaceControl(mvIMPACT::acquire::Device *)\n"); 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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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_mvCustomData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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::mvCustomData *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_mvCustomData" "', 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_mvCustomData" "', argument " "2"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_mvCustomData" "', argument " "2"" of type '" "std::string const &""'"); }
     arg2 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::mvCustomData *)new mvIMPACT::acquire::GenICam::mvCustomData(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCustomData, 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_mvCustomData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::mvCustomData *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_mvCustomData" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::mvCustomData *)new mvIMPACT::acquire::GenICam::mvCustomData(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCustomData, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_new_mvCustomData(PyObject *self, PyObject *args) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_mvCustomData",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_mvCustomData__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_mvCustomData__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_mvCustomData'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::mvCustomData(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::mvCustomData(mvIMPACT::acquire::Device *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_mvCustomData_mvCustomText_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 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__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvCustomText_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->mvCustomText); 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_mvCustomData_mvWriteCustomData_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 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__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvWriteCustomData_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->mvWriteCustomData); 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_mvCustomData_mvReadCustomData_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 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__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvReadCustomData_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->mvReadCustomData); 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_mvCustomData_mvSensorRegister_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvSensorRegister_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(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_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvCustomData_mvSensorRegisterValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvSensorRegisterValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(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_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvCustomData_mvInternalRegister_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvInternalRegister_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvInternalRegister); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvCustomData_mvInternalRegisterValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvInternalRegisterValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvInternalRegisterValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvCustomData_mvMSeqRegister_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvMSeqRegister_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvMSeqRegister); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvCustomData_mvMSeqRegisterValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvMSeqRegisterValue_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvMSeqRegisterValue); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvCustomData_mvStateSumRegister_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvStateSumRegister_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvStateSumRegister); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvCustomData_mvStat2SumRegister_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvStat2SumRegister_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvStat2SumRegister); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvCustomData_mvStateSumRegisterReset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 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__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvStateSumRegisterReset_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->mvStateSumRegisterReset); 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_mvCustomData_mvLVDSSelection_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvLVDSSelection_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLVDSSelection); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvCustomData_mvLVDSAlignment_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvLVDSAlignment_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvLVDSAlignment); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvCustomData_mvRunTest_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 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__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvRunTest_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::Method *)& ((arg1)->mvRunTest); 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_mvCustomData_mvTestNumber_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvTestNumber_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvTestNumber); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvCustomData_mvTestMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvTestMin_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvTestMin); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvCustomData_mvTestMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 0 ; void *argp1 = 0 ;
  int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvTestMax_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvTestMax); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvCustomData_mvCustomCommandInterpreterVersionMajor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvCustomCommandInterpreterVersionMajor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvCustomCommandInterpreterVersionMajor);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvCustomData_mvCustomCommandInterpreterVersionMinor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvCustomCommandInterpreterVersionMinor_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvCustomCommandInterpreterVersionMinor);
    SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvCustomData_mvCustomCommandBuffer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 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__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvCustomCommandBuffer_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyS *)& ((arg1)->mvCustomCommandBuffer); 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_mvCustomData_mvImxSensorType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvImxSensorType_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvImxSensorType); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvCustomData_mvImxSensorIdOne_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvImxSensorIdOne_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvImxSensorIdOne); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvCustomData_mvImxGroup_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvImxGroup_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvImxGroup); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_mvCustomData_mvImxSensorIdTwo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; mvIMPACT::acquire::PropertyI64 *result = 0 ; if (!args) SWIG_fail;
  swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCustomData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mvCustomData_mvImxSensorIdTwo_get" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (mvIMPACT::acquire::PropertyI64 *)& ((arg1)->mvImxSensorIdTwo); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_mvCustomData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::mvCustomData *arg1 = (mvIMPACT::acquire::GenICam::mvCustomData *) 0 ; void *argp1 = 0 ;
  int res1 = 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__mvCustomData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_mvCustomData" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::mvCustomData *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::mvCustomData * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *mvCustomData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__mvCustomData, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

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

SWIGINTERN PyObject *_wrap_new_mvLogicGateControl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::mvLogicGateControl *)new mvIMPACT::acquire::GenICam::mvLogicGateControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::mvLogicGateControl *)new mvIMPACT::acquire::GenICam::mvLogicGateControl(arg1); }  
         catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_mvLogicGateControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_mvLogicGateControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_mvLogicGateControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_mvLogicGateControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::mvLogicGateControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::mvLogicGateControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::mvCurrentControl *)new mvIMPACT::acquire::GenICam::mvCurrentControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::mvCurrentControl *)new mvIMPACT::acquire::GenICam::mvCurrentControl(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_mvCurrentControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_mvCurrentControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_mvCurrentControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_mvCurrentControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::mvCurrentControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::mvCurrentControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::mvLensControl *)new mvIMPACT::acquire::GenICam::mvLensControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::mvLensControl *)new mvIMPACT::acquire::GenICam::mvLensControl(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_mvLensControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_mvLensControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_mvLensControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_mvLensControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::mvLensControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::mvLensControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::mvFFCControl *)new mvIMPACT::acquire::GenICam::mvFFCControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::mvFFCControl *)new mvIMPACT::acquire::GenICam::mvFFCControl(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_mvFFCControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_mvFFCControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_mvFFCControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_mvFFCControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::mvFFCControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::mvFFCControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::mvFrameAverageControl *)new mvIMPACT::acquire::GenICam::mvFrameAverageControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::mvFrameAverageControl *)new mvIMPACT::acquire::GenICam::mvFrameAverageControl(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_mvFrameAverageControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_mvFrameAverageControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_mvFrameAverageControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_mvFrameAverageControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::mvFrameAverageControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::mvFrameAverageControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::mvHDRControl *)new mvIMPACT::acquire::GenICam::mvHDRControl(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::mvHDRControl *)new mvIMPACT::acquire::GenICam::mvHDRControl(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_mvHDRControl",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_mvHDRControl__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_mvHDRControl__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_mvHDRControl'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::mvHDRControl(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::mvHDRControl(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::SystemModule *)new mvIMPACT::acquire::GenICam::SystemModule(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0; mvIMPACT::acquire::GenICam::SystemModule *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::SystemModule *)new mvIMPACT::acquire::GenICam::SystemModule(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[2];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_SystemModule",0,1,argv))) SWIG_fail; --argc; if (argc == 0) {
    return _wrap_new_SystemModule__SWIG_1(self, argc, argv);}  if (argc == 1) {
    return _wrap_new_SystemModule__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SystemModule'.\n"
  "  Possible C/C++ prototypes are:\n" "    mvIMPACT::acquire::GenICam::SystemModule(mvIMPACT::acquire::Device *)\n"
  "    mvIMPACT::acquire::GenICam::SystemModule()\n"); return NULL; }
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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_t, 0 |  0 );
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ;
  mvIMPACT::acquire::int64_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ;
  mvIMPACT::acquire::GenICam::InterfaceModule *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_InterfaceModule" "', argument " "1"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp1); {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t,  0  | 0); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_InterfaceModule" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterfaceModule" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::InterfaceModule *)new mvIMPACT::acquire::GenICam::InterfaceModule(arg1,arg2); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_new_InterfaceModule__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::int64_type arg1 ; void *argp1 ; int res1 = 0 ;
  mvIMPACT::acquire::GenICam::InterfaceModule *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int64_t,  0  | 0); if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InterfaceModule" "', argument " "1"" of type '" "mvIMPACT::acquire::int64_type""'");  }
       if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterfaceModule" "', argument " "1"" of type '" "mvIMPACT::acquire::int64_type""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp1); arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp; }  }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::InterfaceModule *)new mvIMPACT::acquire::GenICam::InterfaceModule(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_new_InterfaceModule(PyObject *self, PyObject *args) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_InterfaceModule",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_InterfaceModule__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_InterfaceModule__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_InterfaceModule'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::InterfaceModule(mvIMPACT::acquire::Device *,mvIMPACT::acquire::int64_type)\n"
  "    mvIMPACT::acquire::GenICam::InterfaceModule(mvIMPACT::acquire::int64_type)\n"); 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_int64_t_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_int64_t_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_int64_t_t, 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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_t, 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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::DeviceModule *)new mvIMPACT::acquire::GenICam::DeviceModule(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::DeviceModule *)new mvIMPACT::acquire::GenICam::DeviceModule(arg1); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_DeviceModule",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_DeviceModule__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_DeviceModule__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DeviceModule'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::DeviceModule(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::DeviceModule(mvIMPACT::acquire::Device *)\n"); return NULL; }
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_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_t, 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_int64_t_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_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ;
  mvIMPACT::acquire::int64_type arg2 ; std::string *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 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); {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t,  0  | 0); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DataStreamModule" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataStreamModule" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  { 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::DataStreamModule *)new mvIMPACT::acquire::GenICam::DataStreamModule(arg1,arg2,(std::string const &)*arg3); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0; mvIMPACT::acquire::Device *arg1 = (mvIMPACT::acquire::Device *) 0 ;
  mvIMPACT::acquire::int64_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 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); {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t,  0  | 0); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DataStreamModule" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataStreamModule" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::DataStreamModule *)new mvIMPACT::acquire::GenICam::DataStreamModule(arg1,arg2); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_DataStreamModule",0,3,argv))) SWIG_fail; --argc; if (argc == 2) {
    return _wrap_new_DataStreamModule__SWIG_1(self, argc, argv);}  if (argc == 3) {
    return _wrap_new_DataStreamModule__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DataStreamModule'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::DataStreamModule(mvIMPACT::acquire::Device *,mvIMPACT::acquire::int64_type,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::DataStreamModule(mvIMPACT::acquire::Device *,mvIMPACT::acquire::int64_type)\n");
  return NULL; }
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_int64_t_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_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_int64_t_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_mvResendCaptureWindowSize_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_mvResendCaptureWindowSize_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)->mvResendCaptureWindowSize); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_t, 0 |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_DataStreamModule_mvResendFeaturesLocked_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_mvResendFeaturesLocked_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)->mvResendFeaturesLocked); SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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_int64_t_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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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), int 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; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *)new mvIMPACT::acquire::GenICam::CustomCommandGenerator(arg1,(std::string const &)*arg2); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *)new mvIMPACT::acquire::GenICam::CustomCommandGenerator(arg1); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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) { int argc; PyObject *argv[3];
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomCommandGenerator",0,2,argv))) SWIG_fail; --argc; if (argc == 1) {
    return _wrap_new_CustomCommandGenerator__SWIG_1(self, argc, argv);}  if (argc == 2) {
    return _wrap_new_CustomCommandGenerator__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CustomCommandGenerator'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator(mvIMPACT::acquire::Device *,std::string const &)\n"
  "    mvIMPACT::acquire::GenICam::CustomCommandGenerator(mvIMPACT::acquire::Device *)\n"); return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try { (arg1)->discardCommandBuffer(); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  mvIMPACT::acquire::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 ; void *argp2 ;
  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_int64_t,  0  | 0); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->queueTransmissionRequest(arg2,arg3,arg4,arg5,arg6,arg7,arg8); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  mvIMPACT::acquire::int64_type arg2 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ;
  mvIMPACT::acquire::GenICam::TRequestTransmissionMode arg7 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; 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_int64_t,  0  | 0); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->queueTransmissionRequest(arg2,arg3,arg4,arg5,arg6,arg7); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  mvIMPACT::acquire::int64_type arg2 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 ; 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_int64_t,  0  | 0); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CustomCommandGenerator_queueTransmissionRequest" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->queueTransmissionRequest(arg2,arg3,arg4,arg5,arg6); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->queueTransmissionRequest((mvIMPACT::acquire::Request const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->queueTransmissionRequest((mvIMPACT::acquire::Request const *)arg2,arg3,arg4,arg5,arg6,arg7); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->queueTransmissionRequest((mvIMPACT::acquire::Request const *)arg2,arg3,arg4,arg5,arg6); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->queueTransmissionRequest((mvIMPACT::acquire::Request const *)arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->queueTransmissionRequest((mvIMPACT::acquire::Request const *)arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueTransmissionRequest(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[9];
  if (!(argc = SWIG_Python_UnpackTuple(args,"CustomCommandGenerator_queueTransmissionRequest",0,8,argv))) SWIG_fail; --argc;
  if (argc == 2) { return _wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_7(self, argc, argv);}  if (argc == 3) {
    return _wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_6(self, argc, argv);}  if (argc == 6) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_int64_t, 0); _v = SWIG_CheckState(res);}  if (!_v) goto check_3;
    return _wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_2(self, argc, argv);}  check_3: if (argc == 6) {
    return _wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_5(self, argc, argv);}  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;
    return _wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_4(self, argc, argv);}  check_5: if (argc == 7) {
    return _wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_1(self, argc, argv);}  if (argc == 8) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_int64_t, 0); _v = SWIG_CheckState(res);}  if (!_v) goto check_7;
    return _wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_0(self, argc, argv);}  check_7: if (argc == 8) {
    return _wrap_CustomCommandGenerator_queueTransmissionRequest__SWIG_3(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CustomCommandGenerator_queueTransmissionRequest'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    queueTransmissionRequest(mvIMPACT::acquire::GenICam::CustomCommandGenerator *,mvIMPACT::acquire::int64_type,int,int,int,int,mvIMPACT::acquire::GenICam::TRequestTransmissionMode,unsigned int)\n"
  "    queueTransmissionRequest(mvIMPACT::acquire::GenICam::CustomCommandGenerator *,mvIMPACT::acquire::int64_type,int,int,int,int,mvIMPACT::acquire::GenICam::TRequestTransmissionMode)\n"
  "    queueTransmissionRequest(mvIMPACT::acquire::GenICam::CustomCommandGenerator *,mvIMPACT::acquire::int64_type,int,int,int,int)\n"
  "    queueTransmissionRequest(mvIMPACT::acquire::GenICam::CustomCommandGenerator *,mvIMPACT::acquire::Request const *,int,int,int,int,mvIMPACT::acquire::GenICam::TRequestTransmissionMode,unsigned int)\n"
  "    queueTransmissionRequest(mvIMPACT::acquire::GenICam::CustomCommandGenerator *,mvIMPACT::acquire::Request const *,int,int,int,int,mvIMPACT::acquire::GenICam::TRequestTransmissionMode)\n"
  "    queueTransmissionRequest(mvIMPACT::acquire::GenICam::CustomCommandGenerator *,mvIMPACT::acquire::Request const *,int,int,int,int)\n"
  "    queueTransmissionRequest(mvIMPACT::acquire::GenICam::CustomCommandGenerator *,mvIMPACT::acquire::Request const *,unsigned int)\n"
  "    queueTransmissionRequest(mvIMPACT::acquire::GenICam::CustomCommandGenerator *,mvIMPACT::acquire::Request const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_requestTransmission__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  mvIMPACT::acquire::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 ; void *argp2 ;
  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_int64_t,  0  | 0); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->requestTransmission(arg2,arg3,arg4,arg5,arg6,arg7,arg8); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_requestTransmission__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  mvIMPACT::acquire::int64_type arg2 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ;
  mvIMPACT::acquire::GenICam::TRequestTransmissionMode arg7 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; 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_int64_t,  0  | 0); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->requestTransmission(arg2,arg3,arg4,arg5,arg6,arg7); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_requestTransmission__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  mvIMPACT::acquire::int64_type arg2 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ; void *argp1 = 0 ; int res1 = 0 ;
  void *argp2 ; 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_int64_t,  0  | 0); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CustomCommandGenerator_requestTransmission" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->requestTransmission(arg2,arg3,arg4,arg5,arg6); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_requestTransmission__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->requestTransmission((mvIMPACT::acquire::Request const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_requestTransmission__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->requestTransmission((mvIMPACT::acquire::Request const *)arg2,arg3,arg4,arg5,arg6,arg7); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_requestTransmission__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->requestTransmission((mvIMPACT::acquire::Request const *)arg2,arg3,arg4,arg5,arg6); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_requestTransmission__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->requestTransmission((mvIMPACT::acquire::Request const *)arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_requestTransmission__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int 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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->requestTransmission((mvIMPACT::acquire::Request const *)arg2); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_requestTransmission(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[9];
  if (!(argc = SWIG_Python_UnpackTuple(args,"CustomCommandGenerator_requestTransmission",0,8,argv))) SWIG_fail; --argc;
  if (argc == 2) { return _wrap_CustomCommandGenerator_requestTransmission__SWIG_7(self, argc, argv);}  if (argc == 3) {
    return _wrap_CustomCommandGenerator_requestTransmission__SWIG_6(self, argc, argv);}  if (argc == 6) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_int64_t, 0); _v = SWIG_CheckState(res);}  if (!_v) goto check_3;
    return _wrap_CustomCommandGenerator_requestTransmission__SWIG_2(self, argc, argv);}  check_3: if (argc == 6) {
    return _wrap_CustomCommandGenerator_requestTransmission__SWIG_5(self, argc, argv);}  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;
    return _wrap_CustomCommandGenerator_requestTransmission__SWIG_4(self, argc, argv);}  check_5: if (argc == 7) {
    return _wrap_CustomCommandGenerator_requestTransmission__SWIG_1(self, argc, argv);}  if (argc == 8) { int _v = 0; {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_int64_t, 0); _v = SWIG_CheckState(res);}  if (!_v) goto check_7;
    return _wrap_CustomCommandGenerator_requestTransmission__SWIG_0(self, argc, argv);}  check_7: if (argc == 8) {
    return _wrap_CustomCommandGenerator_requestTransmission__SWIG_3(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CustomCommandGenerator_requestTransmission'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    requestTransmission(mvIMPACT::acquire::GenICam::CustomCommandGenerator *,mvIMPACT::acquire::int64_type,int,int,int,int,mvIMPACT::acquire::GenICam::TRequestTransmissionMode,unsigned int)\n"
  "    requestTransmission(mvIMPACT::acquire::GenICam::CustomCommandGenerator *,mvIMPACT::acquire::int64_type,int,int,int,int,mvIMPACT::acquire::GenICam::TRequestTransmissionMode)\n"
  "    requestTransmission(mvIMPACT::acquire::GenICam::CustomCommandGenerator *,mvIMPACT::acquire::int64_type,int,int,int,int)\n"
  "    requestTransmission(mvIMPACT::acquire::GenICam::CustomCommandGenerator *,mvIMPACT::acquire::Request const *,int,int,int,int,mvIMPACT::acquire::GenICam::TRequestTransmissionMode,unsigned int)\n"
  "    requestTransmission(mvIMPACT::acquire::GenICam::CustomCommandGenerator *,mvIMPACT::acquire::Request const *,int,int,int,int,mvIMPACT::acquire::GenICam::TRequestTransmissionMode)\n"
  "    requestTransmission(mvIMPACT::acquire::GenICam::CustomCommandGenerator *,mvIMPACT::acquire::Request const *,int,int,int,int)\n"
  "    requestTransmission(mvIMPACT::acquire::GenICam::CustomCommandGenerator *,mvIMPACT::acquire::Request const *,unsigned int)\n"
  "    requestTransmission(mvIMPACT::acquire::GenICam::CustomCommandGenerator *,mvIMPACT::acquire::Request const *)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_modifySequencerSetValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  mvIMPACT::acquire::int64_type arg2 ; mvIMPACT::acquire::GenICam::TSequencerSetParameter arg3 ;
  mvIMPACT::acquire::int64_type arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; int val3 ; int ecode3 = 0 ;
  void *argp4 ; int res4 = 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); {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t,  0  | 0); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CustomCommandGenerator_modifySequencerSetValue" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CustomCommandGenerator_modifySequencerSetValue" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  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); {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int64_t,  0  | 0); if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CustomCommandGenerator_modifySequencerSetValue" "', argument " "4"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CustomCommandGenerator_modifySequencerSetValue" "', argument " "4"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp4); arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp; }  }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->modifySequencerSetValue(arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_modifySequencerSetValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  mvIMPACT::acquire::int64_type arg2 ; mvIMPACT::acquire::GenICam::TSequencerSetParameter arg3 ; double arg4 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 ; int res2 = 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); {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t,  0  | 0); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CustomCommandGenerator_modifySequencerSetValue" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CustomCommandGenerator_modifySequencerSetValue" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->modifySequencerSetValue(arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_modifySequencerSetValue(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"CustomCommandGenerator_modifySequencerSetValue",0,4,argv))) SWIG_fail; --argc;
  if (argc == 4) { int _v = 0; { int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_int64_t, 0); _v = SWIG_CheckState(res);} 
    if (!_v) goto check_1; return _wrap_CustomCommandGenerator_modifySequencerSetValue__SWIG_0(self, argc, argv);}  check_1:
  if (argc == 4) { return _wrap_CustomCommandGenerator_modifySequencerSetValue__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CustomCommandGenerator_modifySequencerSetValue'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    modifySequencerSetValue(mvIMPACT::acquire::GenICam::CustomCommandGenerator *,mvIMPACT::acquire::int64_type const,mvIMPACT::acquire::GenICam::TSequencerSetParameter const,mvIMPACT::acquire::int64_type const)\n"
  "    modifySequencerSetValue(mvIMPACT::acquire::GenICam::CustomCommandGenerator *,mvIMPACT::acquire::int64_type const,mvIMPACT::acquire::GenICam::TSequencerSetParameter const,double const)\n");
  return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueSequencerSetValueModification__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  mvIMPACT::acquire::int64_type arg2 ; mvIMPACT::acquire::GenICam::TSequencerSetParameter arg3 ;
  mvIMPACT::acquire::int64_type arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; int val3 ; int ecode3 = 0 ;
  void *argp4 ; int res4 = 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); {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t,  0  | 0); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CustomCommandGenerator_queueSequencerSetValueModification" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CustomCommandGenerator_queueSequencerSetValueModification" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  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); {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int64_t,  0  | 0); if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CustomCommandGenerator_queueSequencerSetValueModification" "', argument " "4"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CustomCommandGenerator_queueSequencerSetValueModification" "', argument " "4"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp4); arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp; }  }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->queueSequencerSetValueModification(arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueSequencerSetValueModification__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::CustomCommandGenerator *arg1 = (mvIMPACT::acquire::GenICam::CustomCommandGenerator *) 0 ;
  mvIMPACT::acquire::int64_type arg2 ; mvIMPACT::acquire::GenICam::TSequencerSetParameter arg3 ; double arg4 ; void *argp1 = 0 ;
  int res1 = 0 ; void *argp2 ; int res2 = 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); {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t,  0  | 0); if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CustomCommandGenerator_queueSequencerSetValueModification" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'");  }
       if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CustomCommandGenerator_queueSequencerSetValueModification" "', argument " "2"" of type '" "mvIMPACT::acquire::int64_type const""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp2); arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp; }  }  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (int)(arg1)->queueSequencerSetValueModification(arg2,arg3,arg4); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_CustomCommandGenerator_queueSequencerSetValueModification(PyObject *self, PyObject *args) { int argc;
  PyObject *argv[5];
  if (!(argc = SWIG_Python_UnpackTuple(args,"CustomCommandGenerator_queueSequencerSetValueModification",0,4,argv))) SWIG_fail;
  --argc; if (argc == 4) { int _v = 0; { int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_int64_t, 0);
      _v = SWIG_CheckState(res);}  if (!_v) goto check_1;
    return _wrap_CustomCommandGenerator_queueSequencerSetValueModification__SWIG_0(self, argc, argv);}  check_1:
  if (argc == 4) { return _wrap_CustomCommandGenerator_queueSequencerSetValueModification__SWIG_1(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CustomCommandGenerator_queueSequencerSetValueModification'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    queueSequencerSetValueModification(mvIMPACT::acquire::GenICam::CustomCommandGenerator *,mvIMPACT::acquire::int64_type const,mvIMPACT::acquire::GenICam::TSequencerSetParameter const,mvIMPACT::acquire::int64_type const)\n"
  "    queueSequencerSetValueModification(mvIMPACT::acquire::GenICam::CustomCommandGenerator *,mvIMPACT::acquire::int64_type const,mvIMPACT::acquire::GenICam::TSequencerSetParameter const,double const)\n");
  return NULL; }
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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try { result = (int)(arg1)->sendCommandBuffer(); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try { result = (unsigned int)((mvIMPACT::acquire::GenICam::CustomCommandGenerator const *)arg1)->commandBufferSize(); }   
        catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try { result = (unsigned int)((mvIMPACT::acquire::GenICam::CustomCommandGenerator const *)arg1)->commandBufferSizeUsed(); }
           catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  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,(char*)"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);
}

SWIGINTERN PyObject *_wrap_new_FileProtocolAdapter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::FileProtocolAdapter *result = 0 ;
  if (!SWIG_Python_UnpackTuple(args,"new_FileProtocolAdapter",0,0,0)) SWIG_fail; { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (mvIMPACT::acquire::GenICam::FileProtocolAdapter *)new mvIMPACT::acquire::GenICam::FileProtocolAdapter(); }    
       catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileProtocolAdapter, SWIG_POINTER_NEW |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FileProtocolAdapter_attach__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::FileProtocolAdapter *arg1 = (mvIMPACT::acquire::GenICam::FileProtocolAdapter *) 0 ;
  mvIMPACT::acquire::Device *arg2 = (mvIMPACT::acquire::Device *) 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__GenICam__FileProtocolAdapter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileProtocolAdapter_attach" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::FileProtocolAdapter *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::FileProtocolAdapter * >(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 '" "FileProtocolAdapter_attach" "', argument " "2"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Device * >(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 '" "FileProtocolAdapter_attach" "', argument " "3"" of type '" "std::string const &""'"); }
     if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileProtocolAdapter_attach" "', argument " "3"" of type '" "std::string const &""'"); }
     arg3 = ptr; }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try { result = (bool)(arg1)->attach(arg2,(std::string const &)*arg3); } 
          catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  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_FileProtocolAdapter_attach__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::FileProtocolAdapter *arg1 = (mvIMPACT::acquire::GenICam::FileProtocolAdapter *) 0 ;
  mvIMPACT::acquire::Device *arg2 = (mvIMPACT::acquire::Device *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ;
  int res2 = 0 ; bool result; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileProtocolAdapter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileProtocolAdapter_attach" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::FileProtocolAdapter *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::FileProtocolAdapter * >(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 '" "FileProtocolAdapter_attach" "', argument " "2"" of type '" "mvIMPACT::acquire::Device *""'");  }
   arg2 = reinterpret_cast< mvIMPACT::acquire::Device * >(argp2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)(arg1)->attach(arg2); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_FileProtocolAdapter_attach(PyObject *self, PyObject *args) { int argc; PyObject *argv[4];
  if (!(argc = SWIG_Python_UnpackTuple(args,"FileProtocolAdapter_attach",0,3,argv))) SWIG_fail; --argc; if (argc == 2) {
    return _wrap_FileProtocolAdapter_attach__SWIG_1(self, argc, argv);}  if (argc == 3) {
    return _wrap_FileProtocolAdapter_attach__SWIG_0(self, argc, argv);}  fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FileProtocolAdapter_attach'.\n"
  "  Possible C/C++ prototypes are:\n"
  "    attach(mvIMPACT::acquire::GenICam::FileProtocolAdapter *,mvIMPACT::acquire::Device *,std::string const &)\n"
  "    attach(mvIMPACT::acquire::GenICam::FileProtocolAdapter *,mvIMPACT::acquire::Device *)\n"); return NULL; }
SWIGINTERN PyObject *_wrap_FileProtocolAdapter_openFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::FileProtocolAdapter *arg1 = (mvIMPACT::acquire::GenICam::FileProtocolAdapter *) 0 ;
  char *arg2 = (char *) 0 ; std::ios_base::openmode arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ;
  int alloc2 = 0 ; void *argp3 ; int res3 = 0 ; PyObject *swig_obj[3] ; bool result;
  if (!SWIG_Python_UnpackTuple(args,"FileProtocolAdapter_openFile",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileProtocolAdapter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileProtocolAdapter_openFile" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::FileProtocolAdapter *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::FileProtocolAdapter * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileProtocolAdapter_openFile" "', argument " "2"" of type '" "char const *""'"); }
   arg2 = reinterpret_cast< char * >(buf2); {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__ios_base__openmode,  0  | 0); if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FileProtocolAdapter_openFile" "', argument " "3"" of type '" "std::ios_base::openmode""'");  }
       if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileProtocolAdapter_openFile" "', argument " "3"" of type '" "std::ios_base::openmode""'"); }
     else { std::ios_base::openmode * temp = reinterpret_cast< std::ios_base::openmode * >(argp3); arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp; }  }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)(arg1)->openFile((char const *)arg2,arg3); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; }
SWIGINTERN PyObject *_wrap_FileProtocolAdapter_closeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::FileProtocolAdapter *arg1 = (mvIMPACT::acquire::GenICam::FileProtocolAdapter *) 0 ;
  char *arg2 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ;
  PyObject *swig_obj[2] ; bool result;
  if (!SWIG_Python_UnpackTuple(args,"FileProtocolAdapter_closeFile",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileProtocolAdapter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileProtocolAdapter_closeFile" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::FileProtocolAdapter *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::FileProtocolAdapter * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileProtocolAdapter_closeFile" "', argument " "2"" of type '" "char const *""'"); }
   arg2 = reinterpret_cast< char * >(buf2); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (bool)(arg1)->closeFile((char const *)arg2); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_From_bool(static_cast< bool >(result)); if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; }
SWIGINTERN PyObject *_wrap_FileProtocolAdapter_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::FileProtocolAdapter *arg1 = (mvIMPACT::acquire::GenICam::FileProtocolAdapter *) 0 ;
  char *arg2 = (char *) 0 ; mvIMPACT::acquire::int64_type arg3 ; mvIMPACT::acquire::int64_type arg4 ; char *arg5 = (char *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; void *argp3 ; int res3 = 0 ; void *argp4 ;
  int res4 = 0 ; int res5 ; char *buf5 = 0 ; int alloc5 = 0 ; PyObject *swig_obj[5] ; std::streamsize result;
  if (!SWIG_Python_UnpackTuple(args,"FileProtocolAdapter_write",5,5,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileProtocolAdapter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileProtocolAdapter_write" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::FileProtocolAdapter *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::FileProtocolAdapter * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileProtocolAdapter_write" "', argument " "2"" of type '" "char const *""'"); }
   arg2 = reinterpret_cast< char * >(buf2); { res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FileProtocolAdapter_write" "', argument " "3"" of type '" "mvIMPACT::acquire::int64_type""'");  }
       if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileProtocolAdapter_write" "', argument " "3"" of type '" "mvIMPACT::acquire::int64_type""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp3); arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp; }  }  { res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FileProtocolAdapter_write" "', argument " "4"" of type '" "mvIMPACT::acquire::int64_type""'");  }
       if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileProtocolAdapter_write" "', argument " "4"" of type '" "mvIMPACT::acquire::int64_type""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp4); arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp; }  }  res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FileProtocolAdapter_write" "', argument " "5"" of type '" "char const *""'"); }
   arg5 = reinterpret_cast< char * >(buf5); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (arg1)->write((char const *)arg2,arg3,arg4,(char const *)arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new std::streamsize(static_cast< const std::streamsize& >(result))), SWIGTYPE_p_std__streamsize, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2; if (alloc5 == SWIG_NEWOBJ) delete[] buf5; return resultobj; fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2; if (alloc5 == SWIG_NEWOBJ) delete[] buf5; return NULL; }
SWIGINTERN PyObject *_wrap_FileProtocolAdapter_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::FileProtocolAdapter *arg1 = (mvIMPACT::acquire::GenICam::FileProtocolAdapter *) 0 ;
  char *arg2 = (char *) 0 ; mvIMPACT::acquire::int64_type arg3 ; std::streamsize arg4 ; char *arg5 = (char *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; void *argp3 ; int res3 = 0 ; void *argp4 ;
  int res4 = 0 ; int res5 ; char *buf5 = 0 ; int alloc5 = 0 ; PyObject *swig_obj[5] ; std::streamsize result;
  if (!SWIG_Python_UnpackTuple(args,"FileProtocolAdapter_read",5,5,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileProtocolAdapter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileProtocolAdapter_read" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::FileProtocolAdapter *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::FileProtocolAdapter * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileProtocolAdapter_read" "', argument " "2"" of type '" "char *""'"); }
   arg2 = reinterpret_cast< char * >(buf2); { res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int64_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FileProtocolAdapter_read" "', argument " "3"" of type '" "mvIMPACT::acquire::int64_type""'");  }
       if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileProtocolAdapter_read" "', argument " "3"" of type '" "mvIMPACT::acquire::int64_type""'"); }
     else { mvIMPACT::acquire::int64_type * temp = reinterpret_cast< mvIMPACT::acquire::int64_type * >(argp3); arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp; }  }  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_std__streamsize,  0  | 0); if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FileProtocolAdapter_read" "', argument " "4"" of type '" "std::streamsize""'");  }
       if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileProtocolAdapter_read" "', argument " "4"" of type '" "std::streamsize""'"); }
     else { std::streamsize * temp = reinterpret_cast< std::streamsize * >(argp4); arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp; }  }  res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FileProtocolAdapter_read" "', argument " "5"" of type '" "char const *""'"); }
   arg5 = reinterpret_cast< char * >(buf5); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (arg1)->read(arg2,arg3,arg4,(char const *)arg5); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new std::streamsize(static_cast< const std::streamsize& >(result))), SWIGTYPE_p_std__streamsize, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2; if (alloc5 == SWIG_NEWOBJ) delete[] buf5; return resultobj; fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2; if (alloc5 == SWIG_NEWOBJ) delete[] buf5; return NULL; }
SWIGINTERN PyObject *_wrap_FileProtocolAdapter_getBufSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::FileProtocolAdapter *arg1 = (mvIMPACT::acquire::GenICam::FileProtocolAdapter *) 0 ;
  char *arg2 = (char *) 0 ; std::ios_base::openmode arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ;
  int alloc2 = 0 ; void *argp3 ; int res3 = 0 ; PyObject *swig_obj[3] ; mvIMPACT::acquire::int64_type result;
  if (!SWIG_Python_UnpackTuple(args,"FileProtocolAdapter_getBufSize",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileProtocolAdapter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileProtocolAdapter_getBufSize" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::FileProtocolAdapter *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::FileProtocolAdapter * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileProtocolAdapter_getBufSize" "', argument " "2"" of type '" "char const *""'"); }
   arg2 = reinterpret_cast< char * >(buf2); {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__ios_base__openmode,  0  | 0); if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FileProtocolAdapter_getBufSize" "', argument " "3"" of type '" "std::ios_base::openmode""'");  }
       if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileProtocolAdapter_getBufSize" "', argument " "3"" of type '" "std::ios_base::openmode""'"); }
     else { std::ios_base::openmode * temp = reinterpret_cast< std::ios_base::openmode * >(argp3); arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp; }  }  { SWIG_PYTHON_THREAD_BEGIN_ALLOW; { try {
        result = (arg1)->getBufSize((char const *)arg2,arg3); }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) {
        handleImpactAcquireException(e); SWIG_fail; }   catch(const std::exception &e) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new mvIMPACT::acquire::int64_type(static_cast< const mvIMPACT::acquire::int64_type& >(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; }
SWIGINTERN PyObject *_wrap_FileProtocolAdapter_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::FileProtocolAdapter *arg1 = (mvIMPACT::acquire::GenICam::FileProtocolAdapter *) 0 ;
  void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; std::streamsize result; if (!args) SWIG_fail; swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileProtocolAdapter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileProtocolAdapter_size" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::FileProtocolAdapter const *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::FileProtocolAdapter * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try { result = ((mvIMPACT::acquire::GenICam::FileProtocolAdapter const *)arg1)->size(); }     
      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e); SWIG_fail; }  
      catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; }  catch(...) {
        SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  }  SWIG_PYTHON_THREAD_END_ALLOW; } 
  resultobj = SWIG_NewPointerObj((new std::streamsize(static_cast< const std::streamsize& >(result))), SWIGTYPE_p_std__streamsize, SWIG_POINTER_OWN |  0 );
  return resultobj; fail: return NULL; }
SWIGINTERN PyObject *_wrap_delete_FileProtocolAdapter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0;
  mvIMPACT::acquire::GenICam::FileProtocolAdapter *arg1 = (mvIMPACT::acquire::GenICam::FileProtocolAdapter *) 0 ;
  void *argp1 = 0 ; int res1 = 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__FileProtocolAdapter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileProtocolAdapter" "', argument " "1"" of type '" "mvIMPACT::acquire::GenICam::FileProtocolAdapter *""'");  }
   arg1 = reinterpret_cast< mvIMPACT::acquire::GenICam::FileProtocolAdapter * >(argp1); { SWIG_PYTHON_THREAD_BEGIN_ALLOW; {
      try { delete arg1; }      catch(const mvIMPACT::acquire::ImpactAcquireException &e) { handleImpactAcquireException(e);
        SWIG_fail; }   catch(const std::exception &e) { SWIG_SetErrorMsg(PyExc_RuntimeError, e.what()); SWIG_fail; } 
      catch(...) { SWIG_SetErrorMsg(PyExc_RuntimeError, "unknown C++ exception"); SWIG_fail; }  } 
    SWIG_PYTHON_THREAD_END_ALLOW; }  resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; }
SWIGINTERN PyObject *FileProtocolAdapter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_mvIMPACT__acquire__GenICam__FileProtocolAdapter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

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

static PyMethodDef SwigMethods[] = {
	 { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
	 { (char *)"new_pairstringint", _wrap_new_pairstringint, METH_VARARGS, NULL},
	 { (char *)"pairstringint_first_set", _wrap_pairstringint_first_set, METH_VARARGS, NULL},
	 { (char *)"pairstringint_first_get", (PyCFunction)_wrap_pairstringint_first_get, METH_O, NULL},
	 { (char *)"pairstringint_second_set", _wrap_pairstringint_second_set, METH_VARARGS, NULL},
	 { (char *)"pairstringint_second_get", (PyCFunction)_wrap_pairstringint_second_get, METH_O, NULL},
	 { (char *)"delete_pairstringint", (PyCFunction)_wrap_delete_pairstringint, METH_O, NULL},
	 { (char *)"pairstringint_swigregister", pairstringint_swigregister, METH_VARARGS, NULL},
	 { (char *)"pairstringint_swiginit", pairstringint_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_pairstringdouble", _wrap_new_pairstringdouble, METH_VARARGS, NULL},
	 { (char *)"pairstringdouble_first_set", _wrap_pairstringdouble_first_set, METH_VARARGS, NULL},
	 { (char *)"pairstringdouble_first_get", (PyCFunction)_wrap_pairstringdouble_first_get, METH_O, NULL},
	 { (char *)"pairstringdouble_second_set", _wrap_pairstringdouble_second_set, METH_VARARGS, NULL},
	 { (char *)"pairstringdouble_second_get", (PyCFunction)_wrap_pairstringdouble_second_get, METH_O, NULL},
	 { (char *)"delete_pairstringdouble", (PyCFunction)_wrap_delete_pairstringdouble, METH_O, NULL},
	 { (char *)"pairstringdouble_swigregister", pairstringdouble_swigregister, METH_VARARGS, NULL},
	 { (char *)"pairstringdouble_swiginit", pairstringdouble_swiginit, METH_VARARGS, NULL},
	 { (char *)"ChannelData_iChannelOffset_set", _wrap_ChannelData_iChannelOffset_set, METH_VARARGS, NULL},
	 { (char *)"ChannelData_iChannelOffset_get", (PyCFunction)_wrap_ChannelData_iChannelOffset_get, METH_O, NULL},
	 { (char *)"ChannelData_iLinePitch_set", _wrap_ChannelData_iLinePitch_set, METH_VARARGS, NULL},
	 { (char *)"ChannelData_iLinePitch_get", (PyCFunction)_wrap_ChannelData_iLinePitch_get, METH_O, NULL},
	 { (char *)"ChannelData_iPixelPitch_set", _wrap_ChannelData_iPixelPitch_set, METH_VARARGS, NULL},
	 { (char *)"ChannelData_iPixelPitch_get", (PyCFunction)_wrap_ChannelData_iPixelPitch_get, METH_O, NULL},
	 { (char *)"ChannelData_szChannelDesc_set", _wrap_ChannelData_szChannelDesc_set, METH_VARARGS, NULL},
	 { (char *)"ChannelData_szChannelDesc_get", (PyCFunction)_wrap_ChannelData_szChannelDesc_get, METH_O, NULL},
	 { (char *)"new_ChannelData", (PyCFunction)_wrap_new_ChannelData, METH_NOARGS, NULL},
	 { (char *)"delete_ChannelData", (PyCFunction)_wrap_delete_ChannelData, METH_O, NULL},
	 { (char *)"ChannelData_swigregister", ChannelData_swigregister, METH_VARARGS, NULL},
	 { (char *)"ChannelData_swiginit", ChannelData_swiginit, METH_VARARGS, NULL},
	 { (char *)"ImageBuffer_iBytesPerPixel_set", _wrap_ImageBuffer_iBytesPerPixel_set, METH_VARARGS, NULL},
	 { (char *)"ImageBuffer_iBytesPerPixel_get", (PyCFunction)_wrap_ImageBuffer_iBytesPerPixel_get, METH_O, NULL},
	 { (char *)"ImageBuffer_iHeight_set", _wrap_ImageBuffer_iHeight_set, METH_VARARGS, NULL},
	 { (char *)"ImageBuffer_iHeight_get", (PyCFunction)_wrap_ImageBuffer_iHeight_get, METH_O, NULL},
	 { (char *)"ImageBuffer_iWidth_set", _wrap_ImageBuffer_iWidth_set, METH_VARARGS, NULL},
	 { (char *)"ImageBuffer_iWidth_get", (PyCFunction)_wrap_ImageBuffer_iWidth_get, METH_O, NULL},
	 { (char *)"ImageBuffer_pixelFormat_set", _wrap_ImageBuffer_pixelFormat_set, METH_VARARGS, NULL},
	 { (char *)"ImageBuffer_pixelFormat_get", (PyCFunction)_wrap_ImageBuffer_pixelFormat_get, METH_O, NULL},
	 { (char *)"ImageBuffer_iSize_set", _wrap_ImageBuffer_iSize_set, METH_VARARGS, NULL},
	 { (char *)"ImageBuffer_iSize_get", (PyCFunction)_wrap_ImageBuffer_iSize_get, METH_O, NULL},
	 { (char *)"ImageBuffer_vpData_set", _wrap_ImageBuffer_vpData_set, METH_VARARGS, NULL},
	 { (char *)"ImageBuffer_vpData_get", (PyCFunction)_wrap_ImageBuffer_vpData_get, METH_O, NULL},
	 { (char *)"ImageBuffer_iChannelCount_set", _wrap_ImageBuffer_iChannelCount_set, METH_VARARGS, NULL},
	 { (char *)"ImageBuffer_iChannelCount_get", (PyCFunction)_wrap_ImageBuffer_iChannelCount_get, METH_O, NULL},
	 { (char *)"ImageBuffer_pChannels_set", _wrap_ImageBuffer_pChannels_set, METH_VARARGS, NULL},
	 { (char *)"ImageBuffer_pChannels_get", (PyCFunction)_wrap_ImageBuffer_pChannels_get, METH_O, NULL},
	 { (char *)"new_ImageBuffer", (PyCFunction)_wrap_new_ImageBuffer, METH_NOARGS, NULL},
	 { (char *)"delete_ImageBuffer", (PyCFunction)_wrap_delete_ImageBuffer, METH_O, NULL},
	 { (char *)"ImageBuffer_swigregister", ImageBuffer_swigregister, METH_VARARGS, NULL},
	 { (char *)"ImageBuffer_swiginit", ImageBuffer_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ImpactAcquireException", _wrap_new_ImpactAcquireException, METH_VARARGS, NULL},
	 { (char *)"delete_ImpactAcquireException", (PyCFunction)_wrap_delete_ImpactAcquireException, METH_O, NULL},
	 { (char *)"ImpactAcquireException_getErrorString", (PyCFunction)_wrap_ImpactAcquireException_getErrorString, METH_O, NULL},
	 { (char *)"ImpactAcquireException_getErrorCode", (PyCFunction)_wrap_ImpactAcquireException_getErrorCode, METH_O, NULL},
	 { (char *)"ImpactAcquireException_getErrorCodeAsString", _wrap_ImpactAcquireException_getErrorCodeAsString, METH_VARARGS, NULL},
	 { (char *)"ImpactAcquireException_getErrorOrigin", (PyCFunction)_wrap_ImpactAcquireException_getErrorOrigin, METH_O, NULL},
	 { (char *)"ImpactAcquireException_getArgs", (PyCFunction)_wrap_ImpactAcquireException_getArgs, METH_O, NULL},
	 { (char *)"ImpactAcquireException___str__", (PyCFunction)_wrap_ImpactAcquireException___str__, METH_O, NULL},
	 { (char *)"ImpactAcquireException_swigregister", ImpactAcquireException_swigregister, METH_VARARGS, NULL},
	 { (char *)"ImpactAcquireException_swiginit", ImpactAcquireException_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_EDeviceManager", _wrap_new_EDeviceManager, METH_VARARGS, NULL},
	 { (char *)"delete_EDeviceManager", (PyCFunction)_wrap_delete_EDeviceManager, METH_O, NULL},
	 { (char *)"EDeviceManager_swigregister", EDeviceManager_swigregister, METH_VARARGS, NULL},
	 { (char *)"EDeviceManager_swiginit", EDeviceManager_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_EPropertyHandling", _wrap_new_EPropertyHandling, METH_VARARGS, NULL},
	 { (char *)"delete_EPropertyHandling", (PyCFunction)_wrap_delete_EPropertyHandling, METH_O, NULL},
	 { (char *)"EPropertyHandling_swigregister", EPropertyHandling_swigregister, METH_VARARGS, NULL},
	 { (char *)"EPropertyHandling_swiginit", EPropertyHandling_swiginit, METH_VARARGS, NULL},
	 { (char *)"EComponent_swigregister", EComponent_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ENotAList", _wrap_new_ENotAList, METH_VARARGS, NULL},
	 { (char *)"delete_ENotAList", (PyCFunction)_wrap_delete_ENotAList, METH_O, NULL},
	 { (char *)"ENotAList_swigregister", ENotAList_swigregister, METH_VARARGS, NULL},
	 { (char *)"ENotAList_swiginit", ENotAList_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ENotAProperty", _wrap_new_ENotAProperty, METH_VARARGS, NULL},
	 { (char *)"delete_ENotAProperty", (PyCFunction)_wrap_delete_ENotAProperty, METH_O, NULL},
	 { (char *)"ENotAProperty_swigregister", ENotAProperty_swigregister, METH_VARARGS, NULL},
	 { (char *)"ENotAProperty_swiginit", ENotAProperty_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ENotAMethod", _wrap_new_ENotAMethod, METH_VARARGS, NULL},
	 { (char *)"delete_ENotAMethod", (PyCFunction)_wrap_delete_ENotAMethod, METH_O, NULL},
	 { (char *)"ENotAMethod_swigregister", ENotAMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"ENotAMethod_swiginit", ENotAMethod_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ENoReadRights", _wrap_new_ENoReadRights, METH_VARARGS, NULL},
	 { (char *)"delete_ENoReadRights", (PyCFunction)_wrap_delete_ENoReadRights, METH_O, NULL},
	 { (char *)"ENoReadRights_swigregister", ENoReadRights_swigregister, METH_VARARGS, NULL},
	 { (char *)"ENoReadRights_swiginit", ENoReadRights_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ENoWriteRights", _wrap_new_ENoWriteRights, METH_VARARGS, NULL},
	 { (char *)"delete_ENoWriteRights", (PyCFunction)_wrap_delete_ENoWriteRights, METH_O, NULL},
	 { (char *)"ENoWriteRights_swigregister", ENoWriteRights_swigregister, METH_VARARGS, NULL},
	 { (char *)"ENoWriteRights_swiginit", ENoWriteRights_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ENoModifySizeRights", _wrap_new_ENoModifySizeRights, METH_VARARGS, NULL},
	 { (char *)"delete_ENoModifySizeRights", (PyCFunction)_wrap_delete_ENoModifySizeRights, METH_O, NULL},
	 { (char *)"ENoModifySizeRights_swigregister", ENoModifySizeRights_swigregister, METH_VARARGS, NULL},
	 { (char *)"ENoModifySizeRights_swiginit", ENoModifySizeRights_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_EIncompatibleComponents", _wrap_new_EIncompatibleComponents, METH_VARARGS, NULL},
	 { (char *)"delete_EIncompatibleComponents", (PyCFunction)_wrap_delete_EIncompatibleComponents, METH_O, NULL},
	 { (char *)"EIncompatibleComponents_swigregister", EIncompatibleComponents_swigregister, METH_VARARGS, NULL},
	 { (char *)"EIncompatibleComponents_swiginit", EIncompatibleComponents_swiginit, METH_VARARGS, NULL},
	 { (char *)"EProperty_swigregister", EProperty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EInvalidValue", _wrap_new_EInvalidValue, METH_VARARGS, NULL},
	 { (char *)"delete_EInvalidValue", (PyCFunction)_wrap_delete_EInvalidValue, METH_O, NULL},
	 { (char *)"EInvalidValue_swigregister", EInvalidValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"EInvalidValue_swiginit", EInvalidValue_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_EValIDOutOfBounds", _wrap_new_EValIDOutOfBounds, METH_VARARGS, NULL},
	 { (char *)"delete_EValIDOutOfBounds", (PyCFunction)_wrap_delete_EValIDOutOfBounds, METH_O, NULL},
	 { (char *)"EValIDOutOfBounds_swigregister", EValIDOutOfBounds_swigregister, METH_VARARGS, NULL},
	 { (char *)"EValIDOutOfBounds_swiginit", EValIDOutOfBounds_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ETranslationTableCorrupted", _wrap_new_ETranslationTableCorrupted, METH_VARARGS, NULL},
	 { (char *)"delete_ETranslationTableCorrupted", (PyCFunction)_wrap_delete_ETranslationTableCorrupted, METH_O, NULL},
	 { (char *)"ETranslationTableCorrupted_swigregister", ETranslationTableCorrupted_swigregister, METH_VARARGS, NULL},
	 { (char *)"ETranslationTableCorrupted_swiginit", ETranslationTableCorrupted_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ETranslationTableNotDefined", _wrap_new_ETranslationTableNotDefined, METH_VARARGS, NULL},
	 { (char *)"delete_ETranslationTableNotDefined", (PyCFunction)_wrap_delete_ETranslationTableNotDefined, METH_O, NULL},
	 { (char *)"ETranslationTableNotDefined_swigregister", ETranslationTableNotDefined_swigregister, METH_VARARGS, NULL},
	 { (char *)"ETranslationTableNotDefined_swiginit", ETranslationTableNotDefined_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_EInvalidValueType", _wrap_new_EInvalidValueType, METH_VARARGS, NULL},
	 { (char *)"delete_EInvalidValueType", (PyCFunction)_wrap_delete_EInvalidValueType, METH_O, NULL},
	 { (char *)"EInvalidValueType_swigregister", EInvalidValueType_swigregister, METH_VARARGS, NULL},
	 { (char *)"EInvalidValueType_swiginit", EInvalidValueType_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_EValTooLarge", _wrap_new_EValTooLarge, METH_VARARGS, NULL},
	 { (char *)"delete_EValTooLarge", (PyCFunction)_wrap_delete_EValTooLarge, METH_O, NULL},
	 { (char *)"EValTooLarge_swigregister", EValTooLarge_swigregister, METH_VARARGS, NULL},
	 { (char *)"EValTooLarge_swiginit", EValTooLarge_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_EValTooSmall", _wrap_new_EValTooSmall, METH_VARARGS, NULL},
	 { (char *)"delete_EValTooSmall", (PyCFunction)_wrap_delete_EValTooSmall, METH_O, NULL},
	 { (char *)"EValTooSmall_swigregister", EValTooSmall_swigregister, METH_VARARGS, NULL},
	 { (char *)"EValTooSmall_swiginit", EValTooSmall_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_EValidationFailed", _wrap_new_EValidationFailed, METH_VARARGS, NULL},
	 { (char *)"delete_EValidationFailed", (PyCFunction)_wrap_delete_EValidationFailed, METH_O, NULL},
	 { (char *)"EValidationFailed_swigregister", EValidationFailed_swigregister, METH_VARARGS, NULL},
	 { (char *)"EValidationFailed_swiginit", EValidationFailed_swiginit, METH_VARARGS, NULL},
	 { (char *)"EPropertyList_swigregister", EPropertyList_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EComponentNotFound", _wrap_new_EComponentNotFound, METH_VARARGS, NULL},
	 { (char *)"delete_EComponentNotFound", (PyCFunction)_wrap_delete_EComponentNotFound, METH_O, NULL},
	 { (char *)"EComponentNotFound_swigregister", EComponentNotFound_swigregister, METH_VARARGS, NULL},
	 { (char *)"EComponentNotFound_swiginit", EComponentNotFound_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_EListEntryOccupied", (PyCFunction)_wrap_new_EListEntryOccupied, METH_O, NULL},
	 { (char *)"delete_EListEntryOccupied", (PyCFunction)_wrap_delete_EListEntryOccupied, METH_O, NULL},
	 { (char *)"EListEntryOccupied_swigregister", EListEntryOccupied_swigregister, METH_VARARGS, NULL},
	 { (char *)"EListEntryOccupied_swiginit", EListEntryOccupied_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_EComponentIDInvalid", (PyCFunction)_wrap_new_EComponentIDInvalid, METH_O, NULL},
	 { (char *)"delete_EComponentIDInvalid", (PyCFunction)_wrap_delete_EComponentIDInvalid, METH_O, NULL},
	 { (char *)"EComponentIDInvalid_swigregister", EComponentIDInvalid_swigregister, METH_VARARGS, NULL},
	 { (char *)"EComponentIDInvalid_swiginit", EComponentIDInvalid_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_EInvalidListID", _wrap_new_EInvalidListID, METH_VARARGS, NULL},
	 { (char *)"delete_EInvalidListID", (PyCFunction)_wrap_delete_EInvalidListID, METH_O, NULL},
	 { (char *)"EInvalidListID_swigregister", EInvalidListID_swigregister, METH_VARARGS, NULL},
	 { (char *)"EInvalidListID_swiginit", EInvalidListID_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ECantAccessData", _wrap_new_ECantAccessData, METH_VARARGS, NULL},
	 { (char *)"delete_ECantAccessData", (PyCFunction)_wrap_delete_ECantAccessData, METH_O, NULL},
	 { (char *)"ECantAccessData_swigregister", ECantAccessData_swigregister, METH_VARARGS, NULL},
	 { (char *)"ECantAccessData_swiginit", ECantAccessData_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ECantRegisterComponent", _wrap_new_ECantRegisterComponent, METH_VARARGS, NULL},
	 { (char *)"delete_ECantRegisterComponent", (PyCFunction)_wrap_delete_ECantRegisterComponent, METH_O, NULL},
	 { (char *)"ECantRegisterComponent_swigregister", ECantRegisterComponent_swigregister, METH_VARARGS, NULL},
	 { (char *)"ECantRegisterComponent_swiginit", ECantRegisterComponent_swiginit, METH_VARARGS, NULL},
	 { (char *)"EMethod_swigregister", EMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EMethodPtrInvalid", _wrap_new_EMethodPtrInvalid, METH_VARARGS, NULL},
	 { (char *)"delete_EMethodPtrInvalid", (PyCFunction)_wrap_delete_EMethodPtrInvalid, METH_O, NULL},
	 { (char *)"EMethodPtrInvalid_swigregister", EMethodPtrInvalid_swigregister, METH_VARARGS, NULL},
	 { (char *)"EMethodPtrInvalid_swiginit", EMethodPtrInvalid_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_EInvalidParameterList", _wrap_new_EInvalidParameterList, METH_VARARGS, NULL},
	 { (char *)"delete_EInvalidParameterList", (PyCFunction)_wrap_delete_EInvalidParameterList, METH_O, NULL},
	 { (char *)"EInvalidParameterList_swigregister", EInvalidParameterList_swigregister, METH_VARARGS, NULL},
	 { (char *)"EInvalidParameterList_swiginit", EInvalidParameterList_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_EUnsupportedParameter", (PyCFunction)_wrap_new_EUnsupportedParameter, METH_O, NULL},
	 { (char *)"delete_EUnsupportedParameter", (PyCFunction)_wrap_delete_EUnsupportedParameter, METH_O, NULL},
	 { (char *)"EUnsupportedParameter_swigregister", EUnsupportedParameter_swigregister, METH_VARARGS, NULL},
	 { (char *)"EUnsupportedParameter_swiginit", EUnsupportedParameter_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ESizeMismatch", _wrap_new_ESizeMismatch, METH_VARARGS, NULL},
	 { (char *)"delete_ESizeMismatch", (PyCFunction)_wrap_delete_ESizeMismatch, METH_O, NULL},
	 { (char *)"ESizeMismatch_swigregister", ESizeMismatch_swigregister, METH_VARARGS, NULL},
	 { (char *)"ESizeMismatch_swiginit", ESizeMismatch_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_EImplementationMissing", _wrap_new_EImplementationMissing, METH_VARARGS, NULL},
	 { (char *)"delete_EImplementationMissing", (PyCFunction)_wrap_delete_EImplementationMissing, METH_O, NULL},
	 { (char *)"EImplementationMissing_swigregister", EImplementationMissing_swigregister, METH_VARARGS, NULL},
	 { (char *)"EImplementationMissing_swiginit", EImplementationMissing_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_EInvalidInputParameter", _wrap_new_EInvalidInputParameter, METH_VARARGS, NULL},
	 { (char *)"delete_EInvalidInputParameter", (PyCFunction)_wrap_delete_EInvalidInputParameter, METH_O, NULL},
	 { (char *)"EInvalidInputParameter_swigregister", EInvalidInputParameter_swigregister, METH_VARARGS, NULL},
	 { (char *)"EInvalidInputParameter_swiginit", EInvalidInputParameter_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_EInputBufferTooSmall", (PyCFunction)_wrap_new_EInputBufferTooSmall, METH_O, NULL},
	 { (char *)"delete_EInputBufferTooSmall", (PyCFunction)_wrap_delete_EInputBufferTooSmall, METH_O, NULL},
	 { (char *)"EInputBufferTooSmall_swigregister", EInputBufferTooSmall_swigregister, METH_VARARGS, NULL},
	 { (char *)"EInputBufferTooSmall_swiginit", EInputBufferTooSmall_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_EWrongParamCount", _wrap_new_EWrongParamCount, METH_VARARGS, NULL},
	 { (char *)"delete_EWrongParamCount", (PyCFunction)_wrap_delete_EWrongParamCount, METH_O, NULL},
	 { (char *)"EWrongParamCount_swigregister", EWrongParamCount_swigregister, METH_VARARGS, NULL},
	 { (char *)"EWrongParamCount_swiginit", EWrongParamCount_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_EUnsupportedOperation", (PyCFunction)_wrap_new_EUnsupportedOperation, METH_O, NULL},
	 { (char *)"delete_EUnsupportedOperation", (PyCFunction)_wrap_delete_EUnsupportedOperation, METH_O, NULL},
	 { (char *)"EUnsupportedOperation_swigregister", EUnsupportedOperation_swigregister, METH_VARARGS, NULL},
	 { (char *)"EUnsupportedOperation_swiginit", EUnsupportedOperation_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ECantSerializeData", _wrap_new_ECantSerializeData, METH_VARARGS, NULL},
	 { (char *)"delete_ECantSerializeData", (PyCFunction)_wrap_delete_ECantSerializeData, METH_O, NULL},
	 { (char *)"ECantSerializeData_swigregister", ECantSerializeData_swigregister, METH_VARARGS, NULL},
	 { (char *)"ECantSerializeData_swiginit", ECantSerializeData_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_EInvalidFileContent", _wrap_new_EInvalidFileContent, METH_VARARGS, NULL},
	 { (char *)"delete_EInvalidFileContent", (PyCFunction)_wrap_delete_EInvalidFileContent, METH_O, NULL},
	 { (char *)"EInvalidFileContent_swigregister", EInvalidFileContent_swigregister, METH_VARARGS, NULL},
	 { (char *)"EInvalidFileContent_swiginit", EInvalidFileContent_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ECantAllocateNewList", (PyCFunction)_wrap_new_ECantAllocateNewList, METH_O, NULL},
	 { (char *)"delete_ECantAllocateNewList", (PyCFunction)_wrap_delete_ECantAllocateNewList, METH_O, NULL},
	 { (char *)"ECantAllocateNewList_swigregister", ECantAllocateNewList_swigregister, METH_VARARGS, NULL},
	 { (char *)"ECantAllocateNewList_swiginit", ECantAllocateNewList_swiginit, METH_VARARGS, NULL},
	 { (char *)"ExceptionFactory_getLastErrorString", (PyCFunction)_wrap_ExceptionFactory_getLastErrorString, METH_NOARGS, NULL},
	 { (char *)"ExceptionFactory_raiseException", _wrap_ExceptionFactory_raiseException, METH_VARARGS, NULL},
	 { (char *)"new_ExceptionFactory", (PyCFunction)_wrap_new_ExceptionFactory, METH_NOARGS, NULL},
	 { (char *)"delete_ExceptionFactory", (PyCFunction)_wrap_delete_ExceptionFactory, METH_O, NULL},
	 { (char *)"ExceptionFactory_swigregister", ExceptionFactory_swigregister, METH_VARARGS, NULL},
	 { (char *)"ExceptionFactory_swiginit", ExceptionFactory_swiginit, METH_VARARGS, NULL},
	 { (char *)"delete_ComponentAccess", (PyCFunction)_wrap_delete_ComponentAccess, METH_O, NULL},
	 { (char *)"ComponentAccess_changedCounter", (PyCFunction)_wrap_ComponentAccess_changedCounter, METH_O, NULL},
	 { (char *)"ComponentAccess_changedCounterAttr", (PyCFunction)_wrap_ComponentAccess_changedCounterAttr, METH_O, NULL},
	 { (char *)"ComponentAccess_hObj", (PyCFunction)_wrap_ComponentAccess_hObj, METH_O, NULL},
	 { (char *)"ComponentAccess_name", (PyCFunction)_wrap_ComponentAccess_name, METH_O, NULL},
	 { (char *)"ComponentAccess_displayName", (PyCFunction)_wrap_ComponentAccess_displayName, METH_O, NULL},
	 { (char *)"ComponentAccess_swigregister", ComponentAccess_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Component", _wrap_new_Component, METH_VARARGS, NULL},
	 { (char *)"Component_firstSibling", (PyCFunction)_wrap_Component_firstSibling, METH_O, NULL},
	 { (char *)"Component_lastSibling", (PyCFunction)_wrap_Component_lastSibling, METH_O, NULL},
	 { (char *)"Component_nextSibling", (PyCFunction)_wrap_Component_nextSibling, METH_O, NULL},
	 { (char *)"Component_firstChild", (PyCFunction)_wrap_Component_firstChild, METH_O, NULL},
	 { (char *)"Component_parent", (PyCFunction)_wrap_Component_parent, METH_O, NULL},
	 { (char *)"Component_docString", (PyCFunction)_wrap_Component_docString, METH_O, NULL},
	 { (char *)"Component_flags", (PyCFunction)_wrap_Component_flags, METH_O, NULL},
	 { (char *)"Component_flagsAsString", _wrap_Component_flagsAsString, METH_VARARGS, NULL},
	 { (char *)"Component_getIsDefault", (PyCFunction)_wrap_Component_getIsDefault, METH_O, NULL},
	 { (char *)"Component_getIsList", (PyCFunction)_wrap_Component_getIsList, METH_O, NULL},
	 { (char *)"Component_getIsMeth", (PyCFunction)_wrap_Component_getIsMeth, METH_O, NULL},
	 { (char *)"Component_getIsProp", (PyCFunction)_wrap_Component_getIsProp, METH_O, NULL},
	 { (char *)"Component_getIsValid", (PyCFunction)_wrap_Component_getIsValid, METH_O, NULL},
	 { (char *)"Component_getIsVisible", (PyCFunction)_wrap_Component_getIsVisible, METH_O, NULL},
	 { (char *)"Component_getIsWriteable", (PyCFunction)_wrap_Component_getIsWriteable, METH_O, NULL},
	 { (char *)"Component_restoreDefault", (PyCFunction)_wrap_Component_restoreDefault, METH_O, NULL},
	 { (char *)"Component_getType", _wrap_Component_getType, METH_VARARGS, NULL},
	 { (char *)"Component_typeAsString", (PyCFunction)_wrap_Component_typeAsString, METH_O, NULL},
	 { (char *)"Component_visibility", (PyCFunction)_wrap_Component_visibility, METH_O, NULL},
	 { (char *)"Component_visibilityAsString", _wrap_Component_visibilityAsString, METH_VARARGS, NULL},
	 { (char *)"Component_representation", (PyCFunction)_wrap_Component_representation, METH_O, NULL},
	 { (char *)"Component_representationAsString", _wrap_Component_representationAsString, METH_VARARGS, NULL},
	 { (char *)"Component_selectedFeatureCount", (PyCFunction)_wrap_Component_selectedFeatureCount, METH_O, NULL},
	 { (char *)"Component_selectingFeatureCount", (PyCFunction)_wrap_Component_selectingFeatureCount, METH_O, NULL},
	 { (char *)"Component_selectedFeatures", _wrap_Component_selectedFeatures, METH_VARARGS, NULL},
	 { (char *)"Component_selectingFeatures", _wrap_Component_selectingFeatures, METH_VARARGS, NULL},
	 { (char *)"Component_selectedFeature", _wrap_Component_selectedFeature, METH_VARARGS, NULL},
	 { (char *)"Component_selectingFeature", _wrap_Component_selectingFeature, METH_VARARGS, NULL},
	 { (char *)"delete_Component", (PyCFunction)_wrap_delete_Component, METH_O, NULL},
	 { (char *)"Component_swigregister", Component_swigregister, METH_VARARGS, NULL},
	 { (char *)"Component_swiginit", Component_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ComponentCallback", _wrap_new_ComponentCallback, METH_VARARGS, NULL},
	 { (char *)"delete_ComponentCallback", (PyCFunction)_wrap_delete_ComponentCallback, METH_O, NULL},
	 { (char *)"ComponentCallback_isComponentRegistered", _wrap_ComponentCallback_isComponentRegistered, METH_VARARGS, NULL},
	 { (char *)"ComponentCallback_registerComponent", _wrap_ComponentCallback_registerComponent, METH_VARARGS, NULL},
	 { (char *)"ComponentCallback_unregisterComponent", _wrap_ComponentCallback_unregisterComponent, METH_VARARGS, NULL},
	 { (char *)"ComponentCallback_execute", _wrap_ComponentCallback_execute, METH_VARARGS, NULL},
	 { (char *)"ComponentCallback_swigregister", ComponentCallback_swigregister, METH_VARARGS, NULL},
	 { (char *)"ComponentCallback_swiginit", ComponentCallback_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ComponentLocatorBase", _wrap_new_ComponentLocatorBase, METH_VARARGS, NULL},
	 { (char *)"ComponentLocatorBase_bindComponent", _wrap_ComponentLocatorBase_bindComponent, METH_VARARGS, NULL},
	 { (char *)"ComponentLocatorBase_bindSearchBase", _wrap_ComponentLocatorBase_bindSearchBase, METH_VARARGS, NULL},
	 { (char *)"ComponentLocatorBase_findComponent", _wrap_ComponentLocatorBase_findComponent, METH_VARARGS, NULL},
	 { (char *)"ComponentLocatorBase_searchbase_id", (PyCFunction)_wrap_ComponentLocatorBase_searchbase_id, METH_O, NULL},
	 { (char *)"delete_ComponentLocatorBase", (PyCFunction)_wrap_delete_ComponentLocatorBase, METH_O, NULL},
	 { (char *)"ComponentLocatorBase_swigregister", ComponentLocatorBase_swigregister, METH_VARARGS, NULL},
	 { (char *)"ComponentLocatorBase_swiginit", ComponentLocatorBase_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ComponentLocator", _wrap_new_ComponentLocator, METH_VARARGS, NULL},
	 { (char *)"delete_ComponentLocator", (PyCFunction)_wrap_delete_ComponentLocator, METH_O, NULL},
	 { (char *)"ComponentLocator_swigregister", ComponentLocator_swigregister, METH_VARARGS, NULL},
	 { (char *)"ComponentLocator_swiginit", ComponentLocator_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ComponentList", _wrap_new_ComponentList, METH_VARARGS, NULL},
	 { (char *)"ComponentList_size", (PyCFunction)_wrap_ComponentList_size, METH_O, NULL},
	 { (char *)"ComponentList_contentDescriptor", (PyCFunction)_wrap_ComponentList_contentDescriptor, METH_O, NULL},
	 { (char *)"delete_ComponentList", (PyCFunction)_wrap_delete_ComponentList, METH_O, NULL},
	 { (char *)"ComponentList_swigregister", ComponentList_swigregister, METH_VARARGS, NULL},
	 { (char *)"ComponentList_swiginit", ComponentList_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_Method", _wrap_new_Method, METH_VARARGS, NULL},
	 { (char *)"Method_call", _wrap_Method_call, METH_VARARGS, NULL},
	 { (char *)"Method_paramList", (PyCFunction)_wrap_Method_paramList, METH_O, NULL},
	 { (char *)"delete_Method", (PyCFunction)_wrap_delete_Method, METH_O, NULL},
	 { (char *)"Method_swigregister", Method_swigregister, METH_VARARGS, NULL},
	 { (char *)"Method_swiginit", Method_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_Property", _wrap_new_Property, METH_VARARGS, NULL},
	 { (char *)"Property_allowsValueCombinations", (PyCFunction)_wrap_Property_allowsValueCombinations, METH_O, NULL},
	 { (char *)"Property_dictSize", (PyCFunction)_wrap_Property_dictSize, METH_O, NULL},
	 { (char *)"Property_getHasDict", (PyCFunction)_wrap_Property_getHasDict, METH_O, NULL},
	 { (char *)"Property_hasMaxValue", (PyCFunction)_wrap_Property_hasMaxValue, METH_O, NULL},
	 { (char *)"Property_hasMinValue", (PyCFunction)_wrap_Property_hasMinValue, METH_O, NULL},
	 { (char *)"Property_hasStepWidth", (PyCFunction)_wrap_Property_hasStepWidth, METH_O, NULL},
	 { (char *)"Property_readS", _wrap_Property_readS, METH_VARARGS, NULL},
	 { (char *)"Property_readSArray", _wrap_Property_readSArray, METH_VARARGS, NULL},
	 { (char *)"Property_removeValue", _wrap_Property_removeValue, METH_VARARGS, NULL},
	 { (char *)"Property_resizeValArray", _wrap_Property_resizeValArray, METH_VARARGS, NULL},
	 { (char *)"Property_stringFormatString", (PyCFunction)_wrap_Property_stringFormatString, METH_O, NULL},
	 { (char *)"Property_valCount", (PyCFunction)_wrap_Property_valCount, METH_O, NULL},
	 { (char *)"Property_maxValCount", (PyCFunction)_wrap_Property_maxValCount, METH_O, NULL},
	 { (char *)"Property_writeS", _wrap_Property_writeS, METH_VARARGS, NULL},
	 { (char *)"delete_Property", (PyCFunction)_wrap_delete_Property, METH_O, NULL},
	 { (char *)"Property_swigregister", Property_swigregister, METH_VARARGS, NULL},
	 { (char *)"Property_swiginit", Property_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyF", _wrap_new_PropertyF, METH_VARARGS, NULL},
	 { (char *)"PropertyF_getTranslationDict", _wrap_PropertyF_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyF_getTranslationDictString", _wrap_PropertyF_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyF_getTranslationDictValue", _wrap_PropertyF_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyF_getTranslationDictStrings", _wrap_PropertyF_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyF_getTranslationDictValues", _wrap_PropertyF_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyF_getMaxValue", (PyCFunction)_wrap_PropertyF_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyF_getMinValue", (PyCFunction)_wrap_PropertyF_getMinValue, METH_O, NULL},
	 { (char *)"PropertyF_getStepWidth", (PyCFunction)_wrap_PropertyF_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyF_read", _wrap_PropertyF_read, METH_VARARGS, NULL},
	 { (char *)"PropertyF_write", _wrap_PropertyF_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyF", (PyCFunction)_wrap_delete_PropertyF, METH_O, NULL},
	 { (char *)"PropertyF_swigregister", PropertyF_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyF_swiginit", PropertyF_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIAcquisitionMode", _wrap_new_PropertyIAcquisitionMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionMode_getTranslationDict", _wrap_PropertyIAcquisitionMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionMode_getTranslationDictString", _wrap_PropertyIAcquisitionMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionMode_getTranslationDictValue", _wrap_PropertyIAcquisitionMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionMode_getTranslationDictStrings", _wrap_PropertyIAcquisitionMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionMode_getTranslationDictValues", _wrap_PropertyIAcquisitionMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionMode_getMaxValue", (PyCFunction)_wrap_PropertyIAcquisitionMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIAcquisitionMode_getMinValue", (PyCFunction)_wrap_PropertyIAcquisitionMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIAcquisitionMode_getStepWidth", (PyCFunction)_wrap_PropertyIAcquisitionMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIAcquisitionMode_read", _wrap_PropertyIAcquisitionMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionMode_write", _wrap_PropertyIAcquisitionMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIAcquisitionMode", (PyCFunction)_wrap_delete_PropertyIAcquisitionMode, METH_O, NULL},
	 { (char *)"PropertyIAcquisitionMode_swigregister", PropertyIAcquisitionMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionMode_swiginit", PropertyIAcquisitionMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIAcquisitionStartStopBehaviour", _wrap_new_PropertyIAcquisitionStartStopBehaviour, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionStartStopBehaviour_getTranslationDict", _wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionStartStopBehaviour_getTranslationDictString", _wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionStartStopBehaviour_getTranslationDictValue", _wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionStartStopBehaviour_getTranslationDictStrings", _wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionStartStopBehaviour_getTranslationDictValues", _wrap_PropertyIAcquisitionStartStopBehaviour_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionStartStopBehaviour_getMaxValue", (PyCFunction)_wrap_PropertyIAcquisitionStartStopBehaviour_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIAcquisitionStartStopBehaviour_getMinValue", (PyCFunction)_wrap_PropertyIAcquisitionStartStopBehaviour_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIAcquisitionStartStopBehaviour_getStepWidth", (PyCFunction)_wrap_PropertyIAcquisitionStartStopBehaviour_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIAcquisitionStartStopBehaviour_read", _wrap_PropertyIAcquisitionStartStopBehaviour_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionStartStopBehaviour_write", _wrap_PropertyIAcquisitionStartStopBehaviour_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIAcquisitionStartStopBehaviour", (PyCFunction)_wrap_delete_PropertyIAcquisitionStartStopBehaviour, METH_O, NULL},
	 { (char *)"PropertyIAcquisitionStartStopBehaviour_swigregister", PropertyIAcquisitionStartStopBehaviour_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionStartStopBehaviour_swiginit", PropertyIAcquisitionStartStopBehaviour_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIAoiMode", _wrap_new_PropertyIAoiMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIAoiMode_getTranslationDict", _wrap_PropertyIAoiMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIAoiMode_getTranslationDictString", _wrap_PropertyIAoiMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIAoiMode_getTranslationDictValue", _wrap_PropertyIAoiMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIAoiMode_getTranslationDictStrings", _wrap_PropertyIAoiMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIAoiMode_getTranslationDictValues", _wrap_PropertyIAoiMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIAoiMode_getMaxValue", (PyCFunction)_wrap_PropertyIAoiMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIAoiMode_getMinValue", (PyCFunction)_wrap_PropertyIAoiMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIAoiMode_getStepWidth", (PyCFunction)_wrap_PropertyIAoiMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIAoiMode_read", _wrap_PropertyIAoiMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIAoiMode_write", _wrap_PropertyIAoiMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIAoiMode", (PyCFunction)_wrap_delete_PropertyIAoiMode, METH_O, NULL},
	 { (char *)"PropertyIAoiMode_swigregister", PropertyIAoiMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIAoiMode_swiginit", PropertyIAoiMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIBayerConversionMode", _wrap_new_PropertyIBayerConversionMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerConversionMode_getTranslationDict", _wrap_PropertyIBayerConversionMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerConversionMode_getTranslationDictString", _wrap_PropertyIBayerConversionMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerConversionMode_getTranslationDictValue", _wrap_PropertyIBayerConversionMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerConversionMode_getTranslationDictStrings", _wrap_PropertyIBayerConversionMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerConversionMode_getTranslationDictValues", _wrap_PropertyIBayerConversionMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerConversionMode_getMaxValue", (PyCFunction)_wrap_PropertyIBayerConversionMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIBayerConversionMode_getMinValue", (PyCFunction)_wrap_PropertyIBayerConversionMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIBayerConversionMode_getStepWidth", (PyCFunction)_wrap_PropertyIBayerConversionMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIBayerConversionMode_read", _wrap_PropertyIBayerConversionMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerConversionMode_write", _wrap_PropertyIBayerConversionMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIBayerConversionMode", (PyCFunction)_wrap_delete_PropertyIBayerConversionMode, METH_O, NULL},
	 { (char *)"PropertyIBayerConversionMode_swigregister", PropertyIBayerConversionMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerConversionMode_swiginit", PropertyIBayerConversionMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIBayerMosaicParity", _wrap_new_PropertyIBayerMosaicParity, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerMosaicParity_getTranslationDict", _wrap_PropertyIBayerMosaicParity_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerMosaicParity_getTranslationDictString", _wrap_PropertyIBayerMosaicParity_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerMosaicParity_getTranslationDictValue", _wrap_PropertyIBayerMosaicParity_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerMosaicParity_getTranslationDictStrings", _wrap_PropertyIBayerMosaicParity_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerMosaicParity_getTranslationDictValues", _wrap_PropertyIBayerMosaicParity_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerMosaicParity_getMaxValue", (PyCFunction)_wrap_PropertyIBayerMosaicParity_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIBayerMosaicParity_getMinValue", (PyCFunction)_wrap_PropertyIBayerMosaicParity_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIBayerMosaicParity_getStepWidth", (PyCFunction)_wrap_PropertyIBayerMosaicParity_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIBayerMosaicParity_read", _wrap_PropertyIBayerMosaicParity_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerMosaicParity_write", _wrap_PropertyIBayerMosaicParity_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIBayerMosaicParity", (PyCFunction)_wrap_delete_PropertyIBayerMosaicParity, METH_O, NULL},
	 { (char *)"PropertyIBayerMosaicParity_swigregister", PropertyIBayerMosaicParity_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerMosaicParity_swiginit", PropertyIBayerMosaicParity_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIBayerWhiteBalanceResult", _wrap_new_PropertyIBayerWhiteBalanceResult, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerWhiteBalanceResult_getTranslationDict", _wrap_PropertyIBayerWhiteBalanceResult_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerWhiteBalanceResult_getTranslationDictString", _wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerWhiteBalanceResult_getTranslationDictValue", _wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerWhiteBalanceResult_getTranslationDictStrings", _wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerWhiteBalanceResult_getTranslationDictValues", _wrap_PropertyIBayerWhiteBalanceResult_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerWhiteBalanceResult_getMaxValue", (PyCFunction)_wrap_PropertyIBayerWhiteBalanceResult_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIBayerWhiteBalanceResult_getMinValue", (PyCFunction)_wrap_PropertyIBayerWhiteBalanceResult_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIBayerWhiteBalanceResult_getStepWidth", (PyCFunction)_wrap_PropertyIBayerWhiteBalanceResult_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIBayerWhiteBalanceResult_read", _wrap_PropertyIBayerWhiteBalanceResult_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerWhiteBalanceResult_write", _wrap_PropertyIBayerWhiteBalanceResult_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIBayerWhiteBalanceResult", (PyCFunction)_wrap_delete_PropertyIBayerWhiteBalanceResult, METH_O, NULL},
	 { (char *)"PropertyIBayerWhiteBalanceResult_swigregister", PropertyIBayerWhiteBalanceResult_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIBayerWhiteBalanceResult_swiginit", PropertyIBayerWhiteBalanceResult_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIBoolean", _wrap_new_PropertyIBoolean, METH_VARARGS, NULL},
	 { (char *)"PropertyIBoolean_getTranslationDict", _wrap_PropertyIBoolean_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIBoolean_getTranslationDictString", _wrap_PropertyIBoolean_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIBoolean_getTranslationDictValue", _wrap_PropertyIBoolean_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIBoolean_getTranslationDictStrings", _wrap_PropertyIBoolean_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIBoolean_getTranslationDictValues", _wrap_PropertyIBoolean_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIBoolean_getMaxValue", (PyCFunction)_wrap_PropertyIBoolean_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIBoolean_getMinValue", (PyCFunction)_wrap_PropertyIBoolean_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIBoolean_getStepWidth", (PyCFunction)_wrap_PropertyIBoolean_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIBoolean_read", _wrap_PropertyIBoolean_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIBoolean_write", _wrap_PropertyIBoolean_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIBoolean", (PyCFunction)_wrap_delete_PropertyIBoolean, METH_O, NULL},
	 { (char *)"PropertyIBoolean_swigregister", PropertyIBoolean_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIBoolean_swiginit", PropertyIBoolean_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyICameraOutput", _wrap_new_PropertyICameraOutput, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraOutput_getTranslationDict", _wrap_PropertyICameraOutput_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraOutput_getTranslationDictString", _wrap_PropertyICameraOutput_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraOutput_getTranslationDictValue", _wrap_PropertyICameraOutput_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraOutput_getTranslationDictStrings", _wrap_PropertyICameraOutput_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraOutput_getTranslationDictValues", _wrap_PropertyICameraOutput_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraOutput_getMaxValue", (PyCFunction)_wrap_PropertyICameraOutput_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyICameraOutput_getMinValue", (PyCFunction)_wrap_PropertyICameraOutput_getMinValue, METH_O, NULL},
	 { (char *)"PropertyICameraOutput_getStepWidth", (PyCFunction)_wrap_PropertyICameraOutput_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyICameraOutput_read", _wrap_PropertyICameraOutput_read, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraOutput_write", _wrap_PropertyICameraOutput_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyICameraOutput", (PyCFunction)_wrap_delete_PropertyICameraOutput, METH_O, NULL},
	 { (char *)"PropertyICameraOutput_swigregister", PropertyICameraOutput_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraOutput_swiginit", PropertyICameraOutput_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIChannelSplitMode", _wrap_new_PropertyIChannelSplitMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIChannelSplitMode_getTranslationDict", _wrap_PropertyIChannelSplitMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIChannelSplitMode_getTranslationDictString", _wrap_PropertyIChannelSplitMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIChannelSplitMode_getTranslationDictValue", _wrap_PropertyIChannelSplitMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIChannelSplitMode_getTranslationDictStrings", _wrap_PropertyIChannelSplitMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIChannelSplitMode_getTranslationDictValues", _wrap_PropertyIChannelSplitMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIChannelSplitMode_getMaxValue", (PyCFunction)_wrap_PropertyIChannelSplitMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIChannelSplitMode_getMinValue", (PyCFunction)_wrap_PropertyIChannelSplitMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIChannelSplitMode_getStepWidth", (PyCFunction)_wrap_PropertyIChannelSplitMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIChannelSplitMode_read", _wrap_PropertyIChannelSplitMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIChannelSplitMode_write", _wrap_PropertyIChannelSplitMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIChannelSplitMode", (PyCFunction)_wrap_delete_PropertyIChannelSplitMode, METH_O, NULL},
	 { (char *)"PropertyIChannelSplitMode_swigregister", PropertyIChannelSplitMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIChannelSplitMode_swiginit", PropertyIChannelSplitMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIColorTwistInputCorrectionMatrixMode", _wrap_new_PropertyIColorTwistInputCorrectionMatrixMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDict", _wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictString", _wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValue", _wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictStrings", _wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValues", _wrap_PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorTwistInputCorrectionMatrixMode_getMaxValue", (PyCFunction)_wrap_PropertyIColorTwistInputCorrectionMatrixMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIColorTwistInputCorrectionMatrixMode_getMinValue", (PyCFunction)_wrap_PropertyIColorTwistInputCorrectionMatrixMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIColorTwistInputCorrectionMatrixMode_getStepWidth", (PyCFunction)_wrap_PropertyIColorTwistInputCorrectionMatrixMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIColorTwistInputCorrectionMatrixMode_read", _wrap_PropertyIColorTwistInputCorrectionMatrixMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorTwistInputCorrectionMatrixMode_write", _wrap_PropertyIColorTwistInputCorrectionMatrixMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIColorTwistInputCorrectionMatrixMode", (PyCFunction)_wrap_delete_PropertyIColorTwistInputCorrectionMatrixMode, METH_O, NULL},
	 { (char *)"PropertyIColorTwistInputCorrectionMatrixMode_swigregister", PropertyIColorTwistInputCorrectionMatrixMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorTwistInputCorrectionMatrixMode_swiginit", PropertyIColorTwistInputCorrectionMatrixMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIColorTwistOutputCorrectionMatrixMode", _wrap_new_PropertyIColorTwistOutputCorrectionMatrixMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDict", _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictString", _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValue", _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictStrings", _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValues", _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorTwistOutputCorrectionMatrixMode_getMaxValue", (PyCFunction)_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIColorTwistOutputCorrectionMatrixMode_getMinValue", (PyCFunction)_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIColorTwistOutputCorrectionMatrixMode_getStepWidth", (PyCFunction)_wrap_PropertyIColorTwistOutputCorrectionMatrixMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIColorTwistOutputCorrectionMatrixMode_read", _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorTwistOutputCorrectionMatrixMode_write", _wrap_PropertyIColorTwistOutputCorrectionMatrixMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIColorTwistOutputCorrectionMatrixMode", (PyCFunction)_wrap_delete_PropertyIColorTwistOutputCorrectionMatrixMode, METH_O, NULL},
	 { (char *)"PropertyIColorTwistOutputCorrectionMatrixMode_swigregister", PropertyIColorTwistOutputCorrectionMatrixMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorTwistOutputCorrectionMatrixMode_swiginit", PropertyIColorTwistOutputCorrectionMatrixMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIColorProcessingMode", _wrap_new_PropertyIColorProcessingMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorProcessingMode_getTranslationDict", _wrap_PropertyIColorProcessingMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorProcessingMode_getTranslationDictString", _wrap_PropertyIColorProcessingMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorProcessingMode_getTranslationDictValue", _wrap_PropertyIColorProcessingMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorProcessingMode_getTranslationDictStrings", _wrap_PropertyIColorProcessingMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorProcessingMode_getTranslationDictValues", _wrap_PropertyIColorProcessingMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorProcessingMode_getMaxValue", (PyCFunction)_wrap_PropertyIColorProcessingMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIColorProcessingMode_getMinValue", (PyCFunction)_wrap_PropertyIColorProcessingMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIColorProcessingMode_getStepWidth", (PyCFunction)_wrap_PropertyIColorProcessingMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIColorProcessingMode_read", _wrap_PropertyIColorProcessingMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorProcessingMode_write", _wrap_PropertyIColorProcessingMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIColorProcessingMode", (PyCFunction)_wrap_delete_PropertyIColorProcessingMode, METH_O, NULL},
	 { (char *)"PropertyIColorProcessingMode_swigregister", PropertyIColorProcessingMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIColorProcessingMode_swiginit", PropertyIColorProcessingMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDarkCurrentFilterMode", _wrap_new_PropertyIDarkCurrentFilterMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIDarkCurrentFilterMode_getTranslationDict", _wrap_PropertyIDarkCurrentFilterMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDarkCurrentFilterMode_getTranslationDictString", _wrap_PropertyIDarkCurrentFilterMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDarkCurrentFilterMode_getTranslationDictValue", _wrap_PropertyIDarkCurrentFilterMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDarkCurrentFilterMode_getTranslationDictStrings", _wrap_PropertyIDarkCurrentFilterMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDarkCurrentFilterMode_getTranslationDictValues", _wrap_PropertyIDarkCurrentFilterMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDarkCurrentFilterMode_getMaxValue", (PyCFunction)_wrap_PropertyIDarkCurrentFilterMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDarkCurrentFilterMode_getMinValue", (PyCFunction)_wrap_PropertyIDarkCurrentFilterMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDarkCurrentFilterMode_getStepWidth", (PyCFunction)_wrap_PropertyIDarkCurrentFilterMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDarkCurrentFilterMode_read", _wrap_PropertyIDarkCurrentFilterMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDarkCurrentFilterMode_write", _wrap_PropertyIDarkCurrentFilterMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDarkCurrentFilterMode", (PyCFunction)_wrap_delete_PropertyIDarkCurrentFilterMode, METH_O, NULL},
	 { (char *)"PropertyIDarkCurrentFilterMode_swigregister", PropertyIDarkCurrentFilterMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDarkCurrentFilterMode_swiginit", PropertyIDarkCurrentFilterMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDefectivePixelsFilterMode", _wrap_new_PropertyIDefectivePixelsFilterMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIDefectivePixelsFilterMode_getTranslationDict", _wrap_PropertyIDefectivePixelsFilterMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDefectivePixelsFilterMode_getTranslationDictString", _wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDefectivePixelsFilterMode_getTranslationDictValue", _wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDefectivePixelsFilterMode_getTranslationDictStrings", _wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDefectivePixelsFilterMode_getTranslationDictValues", _wrap_PropertyIDefectivePixelsFilterMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDefectivePixelsFilterMode_getMaxValue", (PyCFunction)_wrap_PropertyIDefectivePixelsFilterMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDefectivePixelsFilterMode_getMinValue", (PyCFunction)_wrap_PropertyIDefectivePixelsFilterMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDefectivePixelsFilterMode_getStepWidth", (PyCFunction)_wrap_PropertyIDefectivePixelsFilterMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDefectivePixelsFilterMode_read", _wrap_PropertyIDefectivePixelsFilterMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDefectivePixelsFilterMode_write", _wrap_PropertyIDefectivePixelsFilterMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDefectivePixelsFilterMode", (PyCFunction)_wrap_delete_PropertyIDefectivePixelsFilterMode, METH_O, NULL},
	 { (char *)"PropertyIDefectivePixelsFilterMode_swigregister", PropertyIDefectivePixelsFilterMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDefectivePixelsFilterMode_swiginit", PropertyIDefectivePixelsFilterMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDeviceAccessMode", _wrap_new_PropertyIDeviceAccessMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceAccessMode_getTranslationDict", _wrap_PropertyIDeviceAccessMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceAccessMode_getTranslationDictString", _wrap_PropertyIDeviceAccessMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceAccessMode_getTranslationDictValue", _wrap_PropertyIDeviceAccessMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceAccessMode_getTranslationDictStrings", _wrap_PropertyIDeviceAccessMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceAccessMode_getTranslationDictValues", _wrap_PropertyIDeviceAccessMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceAccessMode_getMaxValue", (PyCFunction)_wrap_PropertyIDeviceAccessMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceAccessMode_getMinValue", (PyCFunction)_wrap_PropertyIDeviceAccessMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceAccessMode_getStepWidth", (PyCFunction)_wrap_PropertyIDeviceAccessMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDeviceAccessMode_read", _wrap_PropertyIDeviceAccessMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceAccessMode_write", _wrap_PropertyIDeviceAccessMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDeviceAccessMode", (PyCFunction)_wrap_delete_PropertyIDeviceAccessMode, METH_O, NULL},
	 { (char *)"PropertyIDeviceAccessMode_swigregister", PropertyIDeviceAccessMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceAccessMode_swiginit", PropertyIDeviceAccessMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDeviceCapability", _wrap_new_PropertyIDeviceCapability, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceCapability_getTranslationDict", _wrap_PropertyIDeviceCapability_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceCapability_getTranslationDictString", _wrap_PropertyIDeviceCapability_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceCapability_getTranslationDictValue", _wrap_PropertyIDeviceCapability_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceCapability_getTranslationDictStrings", _wrap_PropertyIDeviceCapability_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceCapability_getTranslationDictValues", _wrap_PropertyIDeviceCapability_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceCapability_getMaxValue", (PyCFunction)_wrap_PropertyIDeviceCapability_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceCapability_getMinValue", (PyCFunction)_wrap_PropertyIDeviceCapability_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceCapability_getStepWidth", (PyCFunction)_wrap_PropertyIDeviceCapability_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDeviceCapability_read", _wrap_PropertyIDeviceCapability_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceCapability_write", _wrap_PropertyIDeviceCapability_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDeviceCapability", (PyCFunction)_wrap_delete_PropertyIDeviceCapability, METH_O, NULL},
	 { (char *)"PropertyIDeviceCapability_swigregister", PropertyIDeviceCapability_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceCapability_swiginit", PropertyIDeviceCapability_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDeviceClass", _wrap_new_PropertyIDeviceClass, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceClass_getTranslationDict", _wrap_PropertyIDeviceClass_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceClass_getTranslationDictString", _wrap_PropertyIDeviceClass_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceClass_getTranslationDictValue", _wrap_PropertyIDeviceClass_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceClass_getTranslationDictStrings", _wrap_PropertyIDeviceClass_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceClass_getTranslationDictValues", _wrap_PropertyIDeviceClass_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceClass_getMaxValue", (PyCFunction)_wrap_PropertyIDeviceClass_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceClass_getMinValue", (PyCFunction)_wrap_PropertyIDeviceClass_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceClass_getStepWidth", (PyCFunction)_wrap_PropertyIDeviceClass_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDeviceClass_read", _wrap_PropertyIDeviceClass_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceClass_write", _wrap_PropertyIDeviceClass_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDeviceClass", (PyCFunction)_wrap_delete_PropertyIDeviceClass, METH_O, NULL},
	 { (char *)"PropertyIDeviceClass_swigregister", PropertyIDeviceClass_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceClass_swiginit", PropertyIDeviceClass_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDeviceInterfaceLayout", _wrap_new_PropertyIDeviceInterfaceLayout, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceInterfaceLayout_getTranslationDict", _wrap_PropertyIDeviceInterfaceLayout_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceInterfaceLayout_getTranslationDictString", _wrap_PropertyIDeviceInterfaceLayout_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceInterfaceLayout_getTranslationDictValue", _wrap_PropertyIDeviceInterfaceLayout_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceInterfaceLayout_getTranslationDictStrings", _wrap_PropertyIDeviceInterfaceLayout_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceInterfaceLayout_getTranslationDictValues", _wrap_PropertyIDeviceInterfaceLayout_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceInterfaceLayout_getMaxValue", (PyCFunction)_wrap_PropertyIDeviceInterfaceLayout_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceInterfaceLayout_getMinValue", (PyCFunction)_wrap_PropertyIDeviceInterfaceLayout_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceInterfaceLayout_getStepWidth", (PyCFunction)_wrap_PropertyIDeviceInterfaceLayout_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDeviceInterfaceLayout_read", _wrap_PropertyIDeviceInterfaceLayout_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceInterfaceLayout_write", _wrap_PropertyIDeviceInterfaceLayout_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDeviceInterfaceLayout", (PyCFunction)_wrap_delete_PropertyIDeviceInterfaceLayout, METH_O, NULL},
	 { (char *)"PropertyIDeviceInterfaceLayout_swigregister", PropertyIDeviceInterfaceLayout_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceInterfaceLayout_swiginit", PropertyIDeviceInterfaceLayout_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDeviceLoadSettings", _wrap_new_PropertyIDeviceLoadSettings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceLoadSettings_getTranslationDict", _wrap_PropertyIDeviceLoadSettings_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceLoadSettings_getTranslationDictString", _wrap_PropertyIDeviceLoadSettings_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceLoadSettings_getTranslationDictValue", _wrap_PropertyIDeviceLoadSettings_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceLoadSettings_getTranslationDictStrings", _wrap_PropertyIDeviceLoadSettings_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceLoadSettings_getTranslationDictValues", _wrap_PropertyIDeviceLoadSettings_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceLoadSettings_getMaxValue", (PyCFunction)_wrap_PropertyIDeviceLoadSettings_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceLoadSettings_getMinValue", (PyCFunction)_wrap_PropertyIDeviceLoadSettings_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceLoadSettings_getStepWidth", (PyCFunction)_wrap_PropertyIDeviceLoadSettings_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDeviceLoadSettings_read", _wrap_PropertyIDeviceLoadSettings_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceLoadSettings_write", _wrap_PropertyIDeviceLoadSettings_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDeviceLoadSettings", (PyCFunction)_wrap_delete_PropertyIDeviceLoadSettings, METH_O, NULL},
	 { (char *)"PropertyIDeviceLoadSettings_swigregister", PropertyIDeviceLoadSettings_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceLoadSettings_swiginit", PropertyIDeviceLoadSettings_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDeviceState", _wrap_new_PropertyIDeviceState, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceState_getTranslationDict", _wrap_PropertyIDeviceState_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceState_getTranslationDictString", _wrap_PropertyIDeviceState_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceState_getTranslationDictValue", _wrap_PropertyIDeviceState_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceState_getTranslationDictStrings", _wrap_PropertyIDeviceState_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceState_getTranslationDictValues", _wrap_PropertyIDeviceState_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceState_getMaxValue", (PyCFunction)_wrap_PropertyIDeviceState_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceState_getMinValue", (PyCFunction)_wrap_PropertyIDeviceState_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceState_getStepWidth", (PyCFunction)_wrap_PropertyIDeviceState_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDeviceState_read", _wrap_PropertyIDeviceState_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceState_write", _wrap_PropertyIDeviceState_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDeviceState", (PyCFunction)_wrap_delete_PropertyIDeviceState, METH_O, NULL},
	 { (char *)"PropertyIDeviceState_swigregister", PropertyIDeviceState_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceState_swiginit", PropertyIDeviceState_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIFlatFieldFilterCorrectionMode", _wrap_new_PropertyIFlatFieldFilterCorrectionMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIFlatFieldFilterCorrectionMode_getTranslationDict", _wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIFlatFieldFilterCorrectionMode_getTranslationDictString", _wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValue", _wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIFlatFieldFilterCorrectionMode_getTranslationDictStrings", _wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValues", _wrap_PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIFlatFieldFilterCorrectionMode_getMaxValue", (PyCFunction)_wrap_PropertyIFlatFieldFilterCorrectionMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIFlatFieldFilterCorrectionMode_getMinValue", (PyCFunction)_wrap_PropertyIFlatFieldFilterCorrectionMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIFlatFieldFilterCorrectionMode_getStepWidth", (PyCFunction)_wrap_PropertyIFlatFieldFilterCorrectionMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIFlatFieldFilterCorrectionMode_read", _wrap_PropertyIFlatFieldFilterCorrectionMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIFlatFieldFilterCorrectionMode_write", _wrap_PropertyIFlatFieldFilterCorrectionMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIFlatFieldFilterCorrectionMode", (PyCFunction)_wrap_delete_PropertyIFlatFieldFilterCorrectionMode, METH_O, NULL},
	 { (char *)"PropertyIFlatFieldFilterCorrectionMode_swigregister", PropertyIFlatFieldFilterCorrectionMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIFlatFieldFilterCorrectionMode_swiginit", PropertyIFlatFieldFilterCorrectionMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIFlatFieldFilterMode", _wrap_new_PropertyIFlatFieldFilterMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIFlatFieldFilterMode_getTranslationDict", _wrap_PropertyIFlatFieldFilterMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIFlatFieldFilterMode_getTranslationDictString", _wrap_PropertyIFlatFieldFilterMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIFlatFieldFilterMode_getTranslationDictValue", _wrap_PropertyIFlatFieldFilterMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIFlatFieldFilterMode_getTranslationDictStrings", _wrap_PropertyIFlatFieldFilterMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIFlatFieldFilterMode_getTranslationDictValues", _wrap_PropertyIFlatFieldFilterMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIFlatFieldFilterMode_getMaxValue", (PyCFunction)_wrap_PropertyIFlatFieldFilterMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIFlatFieldFilterMode_getMinValue", (PyCFunction)_wrap_PropertyIFlatFieldFilterMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIFlatFieldFilterMode_getStepWidth", (PyCFunction)_wrap_PropertyIFlatFieldFilterMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIFlatFieldFilterMode_read", _wrap_PropertyIFlatFieldFilterMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIFlatFieldFilterMode_write", _wrap_PropertyIFlatFieldFilterMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIFlatFieldFilterMode", (PyCFunction)_wrap_delete_PropertyIFlatFieldFilterMode, METH_O, NULL},
	 { (char *)"PropertyIFlatFieldFilterMode_swigregister", PropertyIFlatFieldFilterMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIFlatFieldFilterMode_swiginit", PropertyIFlatFieldFilterMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIHWUpdateResult", _wrap_new_PropertyIHWUpdateResult, METH_VARARGS, NULL},
	 { (char *)"PropertyIHWUpdateResult_getTranslationDict", _wrap_PropertyIHWUpdateResult_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIHWUpdateResult_getTranslationDictString", _wrap_PropertyIHWUpdateResult_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIHWUpdateResult_getTranslationDictValue", _wrap_PropertyIHWUpdateResult_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIHWUpdateResult_getTranslationDictStrings", _wrap_PropertyIHWUpdateResult_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIHWUpdateResult_getTranslationDictValues", _wrap_PropertyIHWUpdateResult_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIHWUpdateResult_getMaxValue", (PyCFunction)_wrap_PropertyIHWUpdateResult_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIHWUpdateResult_getMinValue", (PyCFunction)_wrap_PropertyIHWUpdateResult_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIHWUpdateResult_getStepWidth", (PyCFunction)_wrap_PropertyIHWUpdateResult_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIHWUpdateResult_read", _wrap_PropertyIHWUpdateResult_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIHWUpdateResult_write", _wrap_PropertyIHWUpdateResult_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIHWUpdateResult", (PyCFunction)_wrap_delete_PropertyIHWUpdateResult, METH_O, NULL},
	 { (char *)"PropertyIHWUpdateResult_swigregister", PropertyIHWUpdateResult_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIHWUpdateResult_swiginit", PropertyIHWUpdateResult_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIImageBufferPixelFormat", _wrap_new_PropertyIImageBufferPixelFormat, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageBufferPixelFormat_getTranslationDict", _wrap_PropertyIImageBufferPixelFormat_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageBufferPixelFormat_getTranslationDictString", _wrap_PropertyIImageBufferPixelFormat_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageBufferPixelFormat_getTranslationDictValue", _wrap_PropertyIImageBufferPixelFormat_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageBufferPixelFormat_getTranslationDictStrings", _wrap_PropertyIImageBufferPixelFormat_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageBufferPixelFormat_getTranslationDictValues", _wrap_PropertyIImageBufferPixelFormat_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageBufferPixelFormat_getMaxValue", (PyCFunction)_wrap_PropertyIImageBufferPixelFormat_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIImageBufferPixelFormat_getMinValue", (PyCFunction)_wrap_PropertyIImageBufferPixelFormat_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIImageBufferPixelFormat_getStepWidth", (PyCFunction)_wrap_PropertyIImageBufferPixelFormat_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIImageBufferPixelFormat_read", _wrap_PropertyIImageBufferPixelFormat_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageBufferPixelFormat_write", _wrap_PropertyIImageBufferPixelFormat_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIImageBufferPixelFormat", (PyCFunction)_wrap_delete_PropertyIImageBufferPixelFormat, METH_O, NULL},
	 { (char *)"PropertyIImageBufferPixelFormat_swigregister", PropertyIImageBufferPixelFormat_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageBufferPixelFormat_swiginit", PropertyIImageBufferPixelFormat_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyI64BufferPartDataType", _wrap_new_PropertyI64BufferPartDataType, METH_VARARGS, NULL},
	 { (char *)"PropertyI64BufferPartDataType_getTranslationDict", _wrap_PropertyI64BufferPartDataType_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyI64BufferPartDataType_getTranslationDictString", _wrap_PropertyI64BufferPartDataType_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyI64BufferPartDataType_getTranslationDictValue", _wrap_PropertyI64BufferPartDataType_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyI64BufferPartDataType_getTranslationDictStrings", _wrap_PropertyI64BufferPartDataType_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyI64BufferPartDataType_getTranslationDictValues", _wrap_PropertyI64BufferPartDataType_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyI64BufferPartDataType_getMaxValue", (PyCFunction)_wrap_PropertyI64BufferPartDataType_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyI64BufferPartDataType_getMinValue", (PyCFunction)_wrap_PropertyI64BufferPartDataType_getMinValue, METH_O, NULL},
	 { (char *)"PropertyI64BufferPartDataType_getStepWidth", (PyCFunction)_wrap_PropertyI64BufferPartDataType_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyI64BufferPartDataType_read", _wrap_PropertyI64BufferPartDataType_read, METH_VARARGS, NULL},
	 { (char *)"PropertyI64BufferPartDataType_write", _wrap_PropertyI64BufferPartDataType_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyI64BufferPartDataType", (PyCFunction)_wrap_delete_PropertyI64BufferPartDataType, METH_O, NULL},
	 { (char *)"PropertyI64BufferPartDataType_swigregister", PropertyI64BufferPartDataType_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyI64BufferPartDataType_swiginit", PropertyI64BufferPartDataType_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIImageBufferFormatReinterpreterMode", _wrap_new_PropertyIImageBufferFormatReinterpreterMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageBufferFormatReinterpreterMode_getTranslationDict", _wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageBufferFormatReinterpreterMode_getTranslationDictString", _wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValue", _wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageBufferFormatReinterpreterMode_getTranslationDictStrings", _wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValues", _wrap_PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageBufferFormatReinterpreterMode_getMaxValue", (PyCFunction)_wrap_PropertyIImageBufferFormatReinterpreterMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIImageBufferFormatReinterpreterMode_getMinValue", (PyCFunction)_wrap_PropertyIImageBufferFormatReinterpreterMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIImageBufferFormatReinterpreterMode_getStepWidth", (PyCFunction)_wrap_PropertyIImageBufferFormatReinterpreterMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIImageBufferFormatReinterpreterMode_read", _wrap_PropertyIImageBufferFormatReinterpreterMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageBufferFormatReinterpreterMode_write", _wrap_PropertyIImageBufferFormatReinterpreterMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIImageBufferFormatReinterpreterMode", (PyCFunction)_wrap_delete_PropertyIImageBufferFormatReinterpreterMode, METH_O, NULL},
	 { (char *)"PropertyIImageBufferFormatReinterpreterMode_swigregister", PropertyIImageBufferFormatReinterpreterMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageBufferFormatReinterpreterMode_swiginit", PropertyIImageBufferFormatReinterpreterMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIImageDestinationPixelFormat", _wrap_new_PropertyIImageDestinationPixelFormat, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageDestinationPixelFormat_getTranslationDict", _wrap_PropertyIImageDestinationPixelFormat_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageDestinationPixelFormat_getTranslationDictString", _wrap_PropertyIImageDestinationPixelFormat_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageDestinationPixelFormat_getTranslationDictValue", _wrap_PropertyIImageDestinationPixelFormat_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageDestinationPixelFormat_getTranslationDictStrings", _wrap_PropertyIImageDestinationPixelFormat_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageDestinationPixelFormat_getTranslationDictValues", _wrap_PropertyIImageDestinationPixelFormat_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageDestinationPixelFormat_getMaxValue", (PyCFunction)_wrap_PropertyIImageDestinationPixelFormat_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIImageDestinationPixelFormat_getMinValue", (PyCFunction)_wrap_PropertyIImageDestinationPixelFormat_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIImageDestinationPixelFormat_getStepWidth", (PyCFunction)_wrap_PropertyIImageDestinationPixelFormat_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIImageDestinationPixelFormat_read", _wrap_PropertyIImageDestinationPixelFormat_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageDestinationPixelFormat_write", _wrap_PropertyIImageDestinationPixelFormat_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIImageDestinationPixelFormat", (PyCFunction)_wrap_delete_PropertyIImageDestinationPixelFormat, METH_O, NULL},
	 { (char *)"PropertyIImageDestinationPixelFormat_swigregister", PropertyIImageDestinationPixelFormat_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageDestinationPixelFormat_swiginit", PropertyIImageDestinationPixelFormat_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIImageProcessingFilter", _wrap_new_PropertyIImageProcessingFilter, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingFilter_getTranslationDict", _wrap_PropertyIImageProcessingFilter_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingFilter_getTranslationDictString", _wrap_PropertyIImageProcessingFilter_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingFilter_getTranslationDictValue", _wrap_PropertyIImageProcessingFilter_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingFilter_getTranslationDictStrings", _wrap_PropertyIImageProcessingFilter_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingFilter_getTranslationDictValues", _wrap_PropertyIImageProcessingFilter_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingFilter_getMaxValue", (PyCFunction)_wrap_PropertyIImageProcessingFilter_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIImageProcessingFilter_getMinValue", (PyCFunction)_wrap_PropertyIImageProcessingFilter_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIImageProcessingFilter_getStepWidth", (PyCFunction)_wrap_PropertyIImageProcessingFilter_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIImageProcessingFilter_read", _wrap_PropertyIImageProcessingFilter_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingFilter_write", _wrap_PropertyIImageProcessingFilter_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIImageProcessingFilter", (PyCFunction)_wrap_delete_PropertyIImageProcessingFilter, METH_O, NULL},
	 { (char *)"PropertyIImageProcessingFilter_swigregister", PropertyIImageProcessingFilter_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingFilter_swiginit", PropertyIImageProcessingFilter_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIImageProcessingMode", _wrap_new_PropertyIImageProcessingMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingMode_getTranslationDict", _wrap_PropertyIImageProcessingMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingMode_getTranslationDictString", _wrap_PropertyIImageProcessingMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingMode_getTranslationDictValue", _wrap_PropertyIImageProcessingMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingMode_getTranslationDictStrings", _wrap_PropertyIImageProcessingMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingMode_getTranslationDictValues", _wrap_PropertyIImageProcessingMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingMode_getMaxValue", (PyCFunction)_wrap_PropertyIImageProcessingMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIImageProcessingMode_getMinValue", (PyCFunction)_wrap_PropertyIImageProcessingMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIImageProcessingMode_getStepWidth", (PyCFunction)_wrap_PropertyIImageProcessingMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIImageProcessingMode_read", _wrap_PropertyIImageProcessingMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingMode_write", _wrap_PropertyIImageProcessingMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIImageProcessingMode", (PyCFunction)_wrap_delete_PropertyIImageProcessingMode, METH_O, NULL},
	 { (char *)"PropertyIImageProcessingMode_swigregister", PropertyIImageProcessingMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingMode_swiginit", PropertyIImageProcessingMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIImageProcessingOptimization", _wrap_new_PropertyIImageProcessingOptimization, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingOptimization_getTranslationDict", _wrap_PropertyIImageProcessingOptimization_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingOptimization_getTranslationDictString", _wrap_PropertyIImageProcessingOptimization_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingOptimization_getTranslationDictValue", _wrap_PropertyIImageProcessingOptimization_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingOptimization_getTranslationDictStrings", _wrap_PropertyIImageProcessingOptimization_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingOptimization_getTranslationDictValues", _wrap_PropertyIImageProcessingOptimization_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingOptimization_getMaxValue", (PyCFunction)_wrap_PropertyIImageProcessingOptimization_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIImageProcessingOptimization_getMinValue", (PyCFunction)_wrap_PropertyIImageProcessingOptimization_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIImageProcessingOptimization_getStepWidth", (PyCFunction)_wrap_PropertyIImageProcessingOptimization_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIImageProcessingOptimization_read", _wrap_PropertyIImageProcessingOptimization_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingOptimization_write", _wrap_PropertyIImageProcessingOptimization_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIImageProcessingOptimization", (PyCFunction)_wrap_delete_PropertyIImageProcessingOptimization, METH_O, NULL},
	 { (char *)"PropertyIImageProcessingOptimization_swigregister", PropertyIImageProcessingOptimization_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingOptimization_swiginit", PropertyIImageProcessingOptimization_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIImageProcessingResult", _wrap_new_PropertyIImageProcessingResult, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingResult_getTranslationDict", _wrap_PropertyIImageProcessingResult_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingResult_getTranslationDictString", _wrap_PropertyIImageProcessingResult_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingResult_getTranslationDictValue", _wrap_PropertyIImageProcessingResult_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingResult_getTranslationDictStrings", _wrap_PropertyIImageProcessingResult_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingResult_getTranslationDictValues", _wrap_PropertyIImageProcessingResult_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingResult_getMaxValue", (PyCFunction)_wrap_PropertyIImageProcessingResult_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIImageProcessingResult_getMinValue", (PyCFunction)_wrap_PropertyIImageProcessingResult_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIImageProcessingResult_getStepWidth", (PyCFunction)_wrap_PropertyIImageProcessingResult_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIImageProcessingResult_read", _wrap_PropertyIImageProcessingResult_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingResult_write", _wrap_PropertyIImageProcessingResult_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIImageProcessingResult", (PyCFunction)_wrap_delete_PropertyIImageProcessingResult, METH_O, NULL},
	 { (char *)"PropertyIImageProcessingResult_swigregister", PropertyIImageProcessingResult_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageProcessingResult_swiginit", PropertyIImageProcessingResult_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIRequestImageMemoryMode", _wrap_new_PropertyIRequestImageMemoryMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestImageMemoryMode_getTranslationDict", _wrap_PropertyIRequestImageMemoryMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestImageMemoryMode_getTranslationDictString", _wrap_PropertyIRequestImageMemoryMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestImageMemoryMode_getTranslationDictValue", _wrap_PropertyIRequestImageMemoryMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestImageMemoryMode_getTranslationDictStrings", _wrap_PropertyIRequestImageMemoryMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestImageMemoryMode_getTranslationDictValues", _wrap_PropertyIRequestImageMemoryMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestImageMemoryMode_getMaxValue", (PyCFunction)_wrap_PropertyIRequestImageMemoryMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIRequestImageMemoryMode_getMinValue", (PyCFunction)_wrap_PropertyIRequestImageMemoryMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIRequestImageMemoryMode_getStepWidth", (PyCFunction)_wrap_PropertyIRequestImageMemoryMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIRequestImageMemoryMode_read", _wrap_PropertyIRequestImageMemoryMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestImageMemoryMode_write", _wrap_PropertyIRequestImageMemoryMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIRequestImageMemoryMode", (PyCFunction)_wrap_delete_PropertyIRequestImageMemoryMode, METH_O, NULL},
	 { (char *)"PropertyIRequestImageMemoryMode_swigregister", PropertyIRequestImageMemoryMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestImageMemoryMode_swiginit", PropertyIRequestImageMemoryMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIImageRequestControlMode", _wrap_new_PropertyIImageRequestControlMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageRequestControlMode_getTranslationDict", _wrap_PropertyIImageRequestControlMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageRequestControlMode_getTranslationDictString", _wrap_PropertyIImageRequestControlMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageRequestControlMode_getTranslationDictValue", _wrap_PropertyIImageRequestControlMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageRequestControlMode_getTranslationDictStrings", _wrap_PropertyIImageRequestControlMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageRequestControlMode_getTranslationDictValues", _wrap_PropertyIImageRequestControlMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageRequestControlMode_getMaxValue", (PyCFunction)_wrap_PropertyIImageRequestControlMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIImageRequestControlMode_getMinValue", (PyCFunction)_wrap_PropertyIImageRequestControlMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIImageRequestControlMode_getStepWidth", (PyCFunction)_wrap_PropertyIImageRequestControlMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIImageRequestControlMode_read", _wrap_PropertyIImageRequestControlMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageRequestControlMode_write", _wrap_PropertyIImageRequestControlMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIImageRequestControlMode", (PyCFunction)_wrap_delete_PropertyIImageRequestControlMode, METH_O, NULL},
	 { (char *)"PropertyIImageRequestControlMode_swigregister", PropertyIImageRequestControlMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIImageRequestControlMode_swiginit", PropertyIImageRequestControlMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyILUTGammaMode", _wrap_new_PropertyILUTGammaMode, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTGammaMode_getTranslationDict", _wrap_PropertyILUTGammaMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTGammaMode_getTranslationDictString", _wrap_PropertyILUTGammaMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTGammaMode_getTranslationDictValue", _wrap_PropertyILUTGammaMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTGammaMode_getTranslationDictStrings", _wrap_PropertyILUTGammaMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTGammaMode_getTranslationDictValues", _wrap_PropertyILUTGammaMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTGammaMode_getMaxValue", (PyCFunction)_wrap_PropertyILUTGammaMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyILUTGammaMode_getMinValue", (PyCFunction)_wrap_PropertyILUTGammaMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyILUTGammaMode_getStepWidth", (PyCFunction)_wrap_PropertyILUTGammaMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyILUTGammaMode_read", _wrap_PropertyILUTGammaMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTGammaMode_write", _wrap_PropertyILUTGammaMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyILUTGammaMode", (PyCFunction)_wrap_delete_PropertyILUTGammaMode, METH_O, NULL},
	 { (char *)"PropertyILUTGammaMode_swigregister", PropertyILUTGammaMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTGammaMode_swiginit", PropertyILUTGammaMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyILUTImplementation", _wrap_new_PropertyILUTImplementation, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTImplementation_getTranslationDict", _wrap_PropertyILUTImplementation_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTImplementation_getTranslationDictString", _wrap_PropertyILUTImplementation_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTImplementation_getTranslationDictValue", _wrap_PropertyILUTImplementation_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTImplementation_getTranslationDictStrings", _wrap_PropertyILUTImplementation_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTImplementation_getTranslationDictValues", _wrap_PropertyILUTImplementation_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTImplementation_getMaxValue", (PyCFunction)_wrap_PropertyILUTImplementation_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyILUTImplementation_getMinValue", (PyCFunction)_wrap_PropertyILUTImplementation_getMinValue, METH_O, NULL},
	 { (char *)"PropertyILUTImplementation_getStepWidth", (PyCFunction)_wrap_PropertyILUTImplementation_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyILUTImplementation_read", _wrap_PropertyILUTImplementation_read, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTImplementation_write", _wrap_PropertyILUTImplementation_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyILUTImplementation", (PyCFunction)_wrap_delete_PropertyILUTImplementation, METH_O, NULL},
	 { (char *)"PropertyILUTImplementation_swigregister", PropertyILUTImplementation_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTImplementation_swiginit", PropertyILUTImplementation_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyILUTInterpolationMode", _wrap_new_PropertyILUTInterpolationMode, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTInterpolationMode_getTranslationDict", _wrap_PropertyILUTInterpolationMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTInterpolationMode_getTranslationDictString", _wrap_PropertyILUTInterpolationMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTInterpolationMode_getTranslationDictValue", _wrap_PropertyILUTInterpolationMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTInterpolationMode_getTranslationDictStrings", _wrap_PropertyILUTInterpolationMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTInterpolationMode_getTranslationDictValues", _wrap_PropertyILUTInterpolationMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTInterpolationMode_getMaxValue", (PyCFunction)_wrap_PropertyILUTInterpolationMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyILUTInterpolationMode_getMinValue", (PyCFunction)_wrap_PropertyILUTInterpolationMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyILUTInterpolationMode_getStepWidth", (PyCFunction)_wrap_PropertyILUTInterpolationMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyILUTInterpolationMode_read", _wrap_PropertyILUTInterpolationMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTInterpolationMode_write", _wrap_PropertyILUTInterpolationMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyILUTInterpolationMode", (PyCFunction)_wrap_delete_PropertyILUTInterpolationMode, METH_O, NULL},
	 { (char *)"PropertyILUTInterpolationMode_swigregister", PropertyILUTInterpolationMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTInterpolationMode_swiginit", PropertyILUTInterpolationMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyILUTMapping", _wrap_new_PropertyILUTMapping, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTMapping_getTranslationDict", _wrap_PropertyILUTMapping_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTMapping_getTranslationDictString", _wrap_PropertyILUTMapping_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTMapping_getTranslationDictValue", _wrap_PropertyILUTMapping_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTMapping_getTranslationDictStrings", _wrap_PropertyILUTMapping_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTMapping_getTranslationDictValues", _wrap_PropertyILUTMapping_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTMapping_getMaxValue", (PyCFunction)_wrap_PropertyILUTMapping_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyILUTMapping_getMinValue", (PyCFunction)_wrap_PropertyILUTMapping_getMinValue, METH_O, NULL},
	 { (char *)"PropertyILUTMapping_getStepWidth", (PyCFunction)_wrap_PropertyILUTMapping_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyILUTMapping_read", _wrap_PropertyILUTMapping_read, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTMapping_write", _wrap_PropertyILUTMapping_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyILUTMapping", (PyCFunction)_wrap_delete_PropertyILUTMapping, METH_O, NULL},
	 { (char *)"PropertyILUTMapping_swigregister", PropertyILUTMapping_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTMapping_swiginit", PropertyILUTMapping_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyILUTMode", _wrap_new_PropertyILUTMode, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTMode_getTranslationDict", _wrap_PropertyILUTMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTMode_getTranslationDictString", _wrap_PropertyILUTMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTMode_getTranslationDictValue", _wrap_PropertyILUTMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTMode_getTranslationDictStrings", _wrap_PropertyILUTMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTMode_getTranslationDictValues", _wrap_PropertyILUTMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTMode_getMaxValue", (PyCFunction)_wrap_PropertyILUTMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyILUTMode_getMinValue", (PyCFunction)_wrap_PropertyILUTMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyILUTMode_getStepWidth", (PyCFunction)_wrap_PropertyILUTMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyILUTMode_read", _wrap_PropertyILUTMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTMode_write", _wrap_PropertyILUTMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyILUTMode", (PyCFunction)_wrap_delete_PropertyILUTMode, METH_O, NULL},
	 { (char *)"PropertyILUTMode_swigregister", PropertyILUTMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyILUTMode_swiginit", PropertyILUTMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIMirrorMode", _wrap_new_PropertyIMirrorMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIMirrorMode_getTranslationDict", _wrap_PropertyIMirrorMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIMirrorMode_getTranslationDictString", _wrap_PropertyIMirrorMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIMirrorMode_getTranslationDictValue", _wrap_PropertyIMirrorMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIMirrorMode_getTranslationDictStrings", _wrap_PropertyIMirrorMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIMirrorMode_getTranslationDictValues", _wrap_PropertyIMirrorMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIMirrorMode_getMaxValue", (PyCFunction)_wrap_PropertyIMirrorMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIMirrorMode_getMinValue", (PyCFunction)_wrap_PropertyIMirrorMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIMirrorMode_getStepWidth", (PyCFunction)_wrap_PropertyIMirrorMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIMirrorMode_read", _wrap_PropertyIMirrorMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIMirrorMode_write", _wrap_PropertyIMirrorMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIMirrorMode", (PyCFunction)_wrap_delete_PropertyIMirrorMode, METH_O, NULL},
	 { (char *)"PropertyIMirrorMode_swigregister", PropertyIMirrorMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIMirrorMode_swiginit", PropertyIMirrorMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIMirrorOperationMode", _wrap_new_PropertyIMirrorOperationMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIMirrorOperationMode_getTranslationDict", _wrap_PropertyIMirrorOperationMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIMirrorOperationMode_getTranslationDictString", _wrap_PropertyIMirrorOperationMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIMirrorOperationMode_getTranslationDictValue", _wrap_PropertyIMirrorOperationMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIMirrorOperationMode_getTranslationDictStrings", _wrap_PropertyIMirrorOperationMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIMirrorOperationMode_getTranslationDictValues", _wrap_PropertyIMirrorOperationMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIMirrorOperationMode_getMaxValue", (PyCFunction)_wrap_PropertyIMirrorOperationMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIMirrorOperationMode_getMinValue", (PyCFunction)_wrap_PropertyIMirrorOperationMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIMirrorOperationMode_getStepWidth", (PyCFunction)_wrap_PropertyIMirrorOperationMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIMirrorOperationMode_read", _wrap_PropertyIMirrorOperationMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIMirrorOperationMode_write", _wrap_PropertyIMirrorOperationMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIMirrorOperationMode", (PyCFunction)_wrap_delete_PropertyIMirrorOperationMode, METH_O, NULL},
	 { (char *)"PropertyIMirrorOperationMode_swigregister", PropertyIMirrorOperationMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIMirrorOperationMode_swiginit", PropertyIMirrorOperationMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIPolarizedDataExtractionMode", _wrap_new_PropertyIPolarizedDataExtractionMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionMode_getTranslationDict", _wrap_PropertyIPolarizedDataExtractionMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionMode_getTranslationDictString", _wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionMode_getTranslationDictValue", _wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionMode_getTranslationDictStrings", _wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionMode_getTranslationDictValues", _wrap_PropertyIPolarizedDataExtractionMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionMode_getMaxValue", (PyCFunction)_wrap_PropertyIPolarizedDataExtractionMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionMode_getMinValue", (PyCFunction)_wrap_PropertyIPolarizedDataExtractionMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionMode_getStepWidth", (PyCFunction)_wrap_PropertyIPolarizedDataExtractionMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionMode_read", _wrap_PropertyIPolarizedDataExtractionMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionMode_write", _wrap_PropertyIPolarizedDataExtractionMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIPolarizedDataExtractionMode", (PyCFunction)_wrap_delete_PropertyIPolarizedDataExtractionMode, METH_O, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionMode_swigregister", PropertyIPolarizedDataExtractionMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionMode_swiginit", PropertyIPolarizedDataExtractionMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIPolarizedDataExtractionInterpolationMode", _wrap_new_PropertyIPolarizedDataExtractionInterpolationMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDict", _wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictString", _wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValue", _wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictStrings", _wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValues", _wrap_PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionInterpolationMode_getMaxValue", (PyCFunction)_wrap_PropertyIPolarizedDataExtractionInterpolationMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionInterpolationMode_getMinValue", (PyCFunction)_wrap_PropertyIPolarizedDataExtractionInterpolationMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionInterpolationMode_getStepWidth", (PyCFunction)_wrap_PropertyIPolarizedDataExtractionInterpolationMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionInterpolationMode_read", _wrap_PropertyIPolarizedDataExtractionInterpolationMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionInterpolationMode_write", _wrap_PropertyIPolarizedDataExtractionInterpolationMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIPolarizedDataExtractionInterpolationMode", (PyCFunction)_wrap_delete_PropertyIPolarizedDataExtractionInterpolationMode, METH_O, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionInterpolationMode_swigregister", PropertyIPolarizedDataExtractionInterpolationMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIPolarizedDataExtractionInterpolationMode_swiginit", PropertyIPolarizedDataExtractionInterpolationMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIRequestResult", _wrap_new_PropertyIRequestResult, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestResult_getTranslationDict", _wrap_PropertyIRequestResult_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestResult_getTranslationDictString", _wrap_PropertyIRequestResult_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestResult_getTranslationDictValue", _wrap_PropertyIRequestResult_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestResult_getTranslationDictStrings", _wrap_PropertyIRequestResult_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestResult_getTranslationDictValues", _wrap_PropertyIRequestResult_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestResult_getMaxValue", (PyCFunction)_wrap_PropertyIRequestResult_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIRequestResult_getMinValue", (PyCFunction)_wrap_PropertyIRequestResult_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIRequestResult_getStepWidth", (PyCFunction)_wrap_PropertyIRequestResult_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIRequestResult_read", _wrap_PropertyIRequestResult_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestResult_write", _wrap_PropertyIRequestResult_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIRequestResult", (PyCFunction)_wrap_delete_PropertyIRequestResult, METH_O, NULL},
	 { (char *)"PropertyIRequestResult_swigregister", PropertyIRequestResult_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestResult_swiginit", PropertyIRequestResult_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIRequestState", _wrap_new_PropertyIRequestState, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestState_getTranslationDict", _wrap_PropertyIRequestState_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestState_getTranslationDictString", _wrap_PropertyIRequestState_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestState_getTranslationDictValue", _wrap_PropertyIRequestState_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestState_getTranslationDictStrings", _wrap_PropertyIRequestState_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestState_getTranslationDictValues", _wrap_PropertyIRequestState_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestState_getMaxValue", (PyCFunction)_wrap_PropertyIRequestState_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIRequestState_getMinValue", (PyCFunction)_wrap_PropertyIRequestState_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIRequestState_getStepWidth", (PyCFunction)_wrap_PropertyIRequestState_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIRequestState_read", _wrap_PropertyIRequestState_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestState_write", _wrap_PropertyIRequestState_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIRequestState", (PyCFunction)_wrap_delete_PropertyIRequestState, METH_O, NULL},
	 { (char *)"PropertyIRequestState_swigregister", PropertyIRequestState_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIRequestState_swiginit", PropertyIRequestState_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIScalerMode", _wrap_new_PropertyIScalerMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIScalerMode_getTranslationDict", _wrap_PropertyIScalerMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIScalerMode_getTranslationDictString", _wrap_PropertyIScalerMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIScalerMode_getTranslationDictValue", _wrap_PropertyIScalerMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIScalerMode_getTranslationDictStrings", _wrap_PropertyIScalerMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIScalerMode_getTranslationDictValues", _wrap_PropertyIScalerMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIScalerMode_getMaxValue", (PyCFunction)_wrap_PropertyIScalerMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIScalerMode_getMinValue", (PyCFunction)_wrap_PropertyIScalerMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIScalerMode_getStepWidth", (PyCFunction)_wrap_PropertyIScalerMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIScalerMode_read", _wrap_PropertyIScalerMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIScalerMode_write", _wrap_PropertyIScalerMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIScalerMode", (PyCFunction)_wrap_delete_PropertyIScalerMode, METH_O, NULL},
	 { (char *)"PropertyIScalerMode_swigregister", PropertyIScalerMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIScalerMode_swiginit", PropertyIScalerMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIScalerInterpolationMode", _wrap_new_PropertyIScalerInterpolationMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIScalerInterpolationMode_getTranslationDict", _wrap_PropertyIScalerInterpolationMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIScalerInterpolationMode_getTranslationDictString", _wrap_PropertyIScalerInterpolationMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIScalerInterpolationMode_getTranslationDictValue", _wrap_PropertyIScalerInterpolationMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIScalerInterpolationMode_getTranslationDictStrings", _wrap_PropertyIScalerInterpolationMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIScalerInterpolationMode_getTranslationDictValues", _wrap_PropertyIScalerInterpolationMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIScalerInterpolationMode_getMaxValue", (PyCFunction)_wrap_PropertyIScalerInterpolationMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIScalerInterpolationMode_getMinValue", (PyCFunction)_wrap_PropertyIScalerInterpolationMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIScalerInterpolationMode_getStepWidth", (PyCFunction)_wrap_PropertyIScalerInterpolationMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIScalerInterpolationMode_read", _wrap_PropertyIScalerInterpolationMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIScalerInterpolationMode_write", _wrap_PropertyIScalerInterpolationMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIScalerInterpolationMode", (PyCFunction)_wrap_delete_PropertyIScalerInterpolationMode, METH_O, NULL},
	 { (char *)"PropertyIScalerInterpolationMode_swigregister", PropertyIScalerInterpolationMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIScalerInterpolationMode_swiginit", PropertyIScalerInterpolationMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIThreadPriority", _wrap_new_PropertyIThreadPriority, METH_VARARGS, NULL},
	 { (char *)"PropertyIThreadPriority_getTranslationDict", _wrap_PropertyIThreadPriority_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIThreadPriority_getTranslationDictString", _wrap_PropertyIThreadPriority_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIThreadPriority_getTranslationDictValue", _wrap_PropertyIThreadPriority_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIThreadPriority_getTranslationDictStrings", _wrap_PropertyIThreadPriority_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIThreadPriority_getTranslationDictValues", _wrap_PropertyIThreadPriority_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIThreadPriority_getMaxValue", (PyCFunction)_wrap_PropertyIThreadPriority_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIThreadPriority_getMinValue", (PyCFunction)_wrap_PropertyIThreadPriority_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIThreadPriority_getStepWidth", (PyCFunction)_wrap_PropertyIThreadPriority_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIThreadPriority_read", _wrap_PropertyIThreadPriority_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIThreadPriority_write", _wrap_PropertyIThreadPriority_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIThreadPriority", (PyCFunction)_wrap_delete_PropertyIThreadPriority, METH_O, NULL},
	 { (char *)"PropertyIThreadPriority_swigregister", PropertyIThreadPriority_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIThreadPriority_swiginit", PropertyIThreadPriority_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIUserDataAccessRight", _wrap_new_PropertyIUserDataAccessRight, METH_VARARGS, NULL},
	 { (char *)"PropertyIUserDataAccessRight_getTranslationDict", _wrap_PropertyIUserDataAccessRight_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIUserDataAccessRight_getTranslationDictString", _wrap_PropertyIUserDataAccessRight_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIUserDataAccessRight_getTranslationDictValue", _wrap_PropertyIUserDataAccessRight_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIUserDataAccessRight_getTranslationDictStrings", _wrap_PropertyIUserDataAccessRight_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIUserDataAccessRight_getTranslationDictValues", _wrap_PropertyIUserDataAccessRight_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIUserDataAccessRight_getMaxValue", (PyCFunction)_wrap_PropertyIUserDataAccessRight_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIUserDataAccessRight_getMinValue", (PyCFunction)_wrap_PropertyIUserDataAccessRight_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIUserDataAccessRight_getStepWidth", (PyCFunction)_wrap_PropertyIUserDataAccessRight_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIUserDataAccessRight_read", _wrap_PropertyIUserDataAccessRight_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIUserDataAccessRight_write", _wrap_PropertyIUserDataAccessRight_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIUserDataAccessRight", (PyCFunction)_wrap_delete_PropertyIUserDataAccessRight, METH_O, NULL},
	 { (char *)"PropertyIUserDataAccessRight_swigregister", PropertyIUserDataAccessRight_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIUserDataAccessRight_swiginit", PropertyIUserDataAccessRight_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIUserDataReconnectBehaviour", _wrap_new_PropertyIUserDataReconnectBehaviour, METH_VARARGS, NULL},
	 { (char *)"PropertyIUserDataReconnectBehaviour_getTranslationDict", _wrap_PropertyIUserDataReconnectBehaviour_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIUserDataReconnectBehaviour_getTranslationDictString", _wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIUserDataReconnectBehaviour_getTranslationDictValue", _wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIUserDataReconnectBehaviour_getTranslationDictStrings", _wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIUserDataReconnectBehaviour_getTranslationDictValues", _wrap_PropertyIUserDataReconnectBehaviour_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIUserDataReconnectBehaviour_getMaxValue", (PyCFunction)_wrap_PropertyIUserDataReconnectBehaviour_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIUserDataReconnectBehaviour_getMinValue", (PyCFunction)_wrap_PropertyIUserDataReconnectBehaviour_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIUserDataReconnectBehaviour_getStepWidth", (PyCFunction)_wrap_PropertyIUserDataReconnectBehaviour_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIUserDataReconnectBehaviour_read", _wrap_PropertyIUserDataReconnectBehaviour_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIUserDataReconnectBehaviour_write", _wrap_PropertyIUserDataReconnectBehaviour_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIUserDataReconnectBehaviour", (PyCFunction)_wrap_delete_PropertyIUserDataReconnectBehaviour, METH_O, NULL},
	 { (char *)"PropertyIUserDataReconnectBehaviour_swigregister", PropertyIUserDataReconnectBehaviour_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIUserDataReconnectBehaviour_swiginit", PropertyIUserDataReconnectBehaviour_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIWhiteBalanceCalibrationMode", _wrap_new_PropertyIWhiteBalanceCalibrationMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIWhiteBalanceCalibrationMode_getTranslationDict", _wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIWhiteBalanceCalibrationMode_getTranslationDictString", _wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIWhiteBalanceCalibrationMode_getTranslationDictValue", _wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIWhiteBalanceCalibrationMode_getTranslationDictStrings", _wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIWhiteBalanceCalibrationMode_getTranslationDictValues", _wrap_PropertyIWhiteBalanceCalibrationMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIWhiteBalanceCalibrationMode_getMaxValue", (PyCFunction)_wrap_PropertyIWhiteBalanceCalibrationMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIWhiteBalanceCalibrationMode_getMinValue", (PyCFunction)_wrap_PropertyIWhiteBalanceCalibrationMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIWhiteBalanceCalibrationMode_getStepWidth", (PyCFunction)_wrap_PropertyIWhiteBalanceCalibrationMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIWhiteBalanceCalibrationMode_read", _wrap_PropertyIWhiteBalanceCalibrationMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIWhiteBalanceCalibrationMode_write", _wrap_PropertyIWhiteBalanceCalibrationMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIWhiteBalanceCalibrationMode", (PyCFunction)_wrap_delete_PropertyIWhiteBalanceCalibrationMode, METH_O, NULL},
	 { (char *)"PropertyIWhiteBalanceCalibrationMode_swigregister", PropertyIWhiteBalanceCalibrationMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIWhiteBalanceCalibrationMode_swiginit", PropertyIWhiteBalanceCalibrationMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIWhiteBalanceParameter", _wrap_new_PropertyIWhiteBalanceParameter, METH_VARARGS, NULL},
	 { (char *)"PropertyIWhiteBalanceParameter_getTranslationDict", _wrap_PropertyIWhiteBalanceParameter_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIWhiteBalanceParameter_getTranslationDictString", _wrap_PropertyIWhiteBalanceParameter_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIWhiteBalanceParameter_getTranslationDictValue", _wrap_PropertyIWhiteBalanceParameter_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIWhiteBalanceParameter_getTranslationDictStrings", _wrap_PropertyIWhiteBalanceParameter_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIWhiteBalanceParameter_getTranslationDictValues", _wrap_PropertyIWhiteBalanceParameter_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIWhiteBalanceParameter_getMaxValue", (PyCFunction)_wrap_PropertyIWhiteBalanceParameter_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIWhiteBalanceParameter_getMinValue", (PyCFunction)_wrap_PropertyIWhiteBalanceParameter_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIWhiteBalanceParameter_getStepWidth", (PyCFunction)_wrap_PropertyIWhiteBalanceParameter_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIWhiteBalanceParameter_read", _wrap_PropertyIWhiteBalanceParameter_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIWhiteBalanceParameter_write", _wrap_PropertyIWhiteBalanceParameter_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIWhiteBalanceParameter", (PyCFunction)_wrap_delete_PropertyIWhiteBalanceParameter, METH_O, NULL},
	 { (char *)"PropertyIWhiteBalanceParameter_swigregister", PropertyIWhiteBalanceParameter_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIWhiteBalanceParameter_swiginit", PropertyIWhiteBalanceParameter_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyI", _wrap_new_PropertyI, METH_VARARGS, NULL},
	 { (char *)"PropertyI_getTranslationDict", _wrap_PropertyI_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyI_getTranslationDictString", _wrap_PropertyI_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyI_getTranslationDictValue", _wrap_PropertyI_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyI_getTranslationDictStrings", _wrap_PropertyI_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyI_getTranslationDictValues", _wrap_PropertyI_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyI_getMaxValue", (PyCFunction)_wrap_PropertyI_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyI_getMinValue", (PyCFunction)_wrap_PropertyI_getMinValue, METH_O, NULL},
	 { (char *)"PropertyI_getStepWidth", (PyCFunction)_wrap_PropertyI_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyI_read", _wrap_PropertyI_read, METH_VARARGS, NULL},
	 { (char *)"PropertyI_write", _wrap_PropertyI_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyI", (PyCFunction)_wrap_delete_PropertyI, METH_O, NULL},
	 { (char *)"PropertyI_swigregister", PropertyI_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyI_swiginit", PropertyI_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyI64", _wrap_new_PropertyI64, METH_VARARGS, NULL},
	 { (char *)"PropertyI64_getTranslationDict", _wrap_PropertyI64_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyI64_getTranslationDictString", _wrap_PropertyI64_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyI64_getTranslationDictValue", _wrap_PropertyI64_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyI64_getTranslationDictStrings", _wrap_PropertyI64_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyI64_getTranslationDictValues", _wrap_PropertyI64_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyI64_getMaxValue", (PyCFunction)_wrap_PropertyI64_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyI64_getMinValue", (PyCFunction)_wrap_PropertyI64_getMinValue, METH_O, NULL},
	 { (char *)"PropertyI64_getStepWidth", (PyCFunction)_wrap_PropertyI64_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyI64_read", _wrap_PropertyI64_read, METH_VARARGS, NULL},
	 { (char *)"PropertyI64_write", _wrap_PropertyI64_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyI64", (PyCFunction)_wrap_delete_PropertyI64, METH_O, NULL},
	 { (char *)"PropertyI64_swigregister", PropertyI64_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyI64_swiginit", PropertyI64_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyI64DeviceTriggerOverlap", _wrap_new_PropertyI64DeviceTriggerOverlap, METH_VARARGS, NULL},
	 { (char *)"PropertyI64DeviceTriggerOverlap_getTranslationDict", _wrap_PropertyI64DeviceTriggerOverlap_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyI64DeviceTriggerOverlap_getTranslationDictString", _wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyI64DeviceTriggerOverlap_getTranslationDictValue", _wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyI64DeviceTriggerOverlap_getTranslationDictStrings", _wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyI64DeviceTriggerOverlap_getTranslationDictValues", _wrap_PropertyI64DeviceTriggerOverlap_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyI64DeviceTriggerOverlap_getMaxValue", (PyCFunction)_wrap_PropertyI64DeviceTriggerOverlap_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyI64DeviceTriggerOverlap_getMinValue", (PyCFunction)_wrap_PropertyI64DeviceTriggerOverlap_getMinValue, METH_O, NULL},
	 { (char *)"PropertyI64DeviceTriggerOverlap_getStepWidth", (PyCFunction)_wrap_PropertyI64DeviceTriggerOverlap_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyI64DeviceTriggerOverlap_read", _wrap_PropertyI64DeviceTriggerOverlap_read, METH_VARARGS, NULL},
	 { (char *)"PropertyI64DeviceTriggerOverlap_write", _wrap_PropertyI64DeviceTriggerOverlap_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyI64DeviceTriggerOverlap", (PyCFunction)_wrap_delete_PropertyI64DeviceTriggerOverlap, METH_O, NULL},
	 { (char *)"PropertyI64DeviceTriggerOverlap_swigregister", PropertyI64DeviceTriggerOverlap_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyI64DeviceTriggerOverlap_swiginit", PropertyI64DeviceTriggerOverlap_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyPtr", _wrap_new_PropertyPtr, METH_VARARGS, NULL},
	 { (char *)"PropertyPtr_read", _wrap_PropertyPtr_read, METH_VARARGS, NULL},
	 { (char *)"PropertyPtr_write", _wrap_PropertyPtr_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyPtr", (PyCFunction)_wrap_delete_PropertyPtr, METH_O, NULL},
	 { (char *)"PropertyPtr_swigregister", PropertyPtr_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyPtr_swiginit", PropertyPtr_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyS", _wrap_new_PropertyS, METH_VARARGS, NULL},
	 { (char *)"PropertyS_binaryDataBufferSize", _wrap_PropertyS_binaryDataBufferSize, METH_VARARGS, NULL},
	 { (char *)"PropertyS_binaryDataBufferMaxSize", (PyCFunction)_wrap_PropertyS_binaryDataBufferMaxSize, METH_O, NULL},
	 { (char *)"PropertyS_read", _wrap_PropertyS_read, METH_VARARGS, NULL},
	 { (char *)"PropertyS_readBinary", _wrap_PropertyS_readBinary, METH_VARARGS, NULL},
	 { (char *)"PropertyS_write", _wrap_PropertyS_write, METH_VARARGS, NULL},
	 { (char *)"PropertyS_writeBinary", _wrap_PropertyS_writeBinary, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyS", (PyCFunction)_wrap_delete_PropertyS, METH_O, NULL},
	 { (char *)"PropertyS_swigregister", PropertyS_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyS_swiginit", PropertyS_swiginit, METH_VARARGS, NULL},
	 { (char *)"UserDataEntry_getUDEIsValid", (PyCFunction)_wrap_UserDataEntry_getUDEIsValid, METH_O, NULL},
	 { (char *)"UserDataEntry_name_get", (PyCFunction)_wrap_UserDataEntry_name_get, METH_O, NULL},
	 { (char *)"UserDataEntry_data_get", (PyCFunction)_wrap_UserDataEntry_data_get, METH_O, NULL},
	 { (char *)"UserDataEntry_access_get", (PyCFunction)_wrap_UserDataEntry_access_get, METH_O, NULL},
	 { (char *)"UserDataEntry_password_get", (PyCFunction)_wrap_UserDataEntry_password_get, METH_O, NULL},
	 { (char *)"delete_UserDataEntry", (PyCFunction)_wrap_delete_UserDataEntry, METH_O, NULL},
	 { (char *)"UserDataEntry_swigregister", UserDataEntry_swigregister, METH_VARARGS, NULL},
	 { (char *)"UserData_createEntry", (PyCFunction)_wrap_UserData_createEntry, METH_O, NULL},
	 { (char *)"UserData_deleteEntry", _wrap_UserData_deleteEntry, METH_VARARGS, NULL},
	 { (char *)"UserData_getFreeMemory", (PyCFunction)_wrap_UserData_getFreeMemory, METH_O, NULL},
	 { (char *)"UserData_getUserDataEntry", _wrap_UserData_getUserDataEntry, METH_VARARGS, NULL},
	 { (char *)"UserData_validUserDataEntryIndexes", _wrap_UserData_validUserDataEntryIndexes, METH_VARARGS, NULL},
	 { (char *)"UserData_getIsAvailable", (PyCFunction)_wrap_UserData_getIsAvailable, METH_O, NULL},
	 { (char *)"UserData_writeToHardware", (PyCFunction)_wrap_UserData_writeToHardware, METH_O, NULL},
	 { (char *)"UserData_reconnectBehaviour_get", (PyCFunction)_wrap_UserData_reconnectBehaviour_get, METH_O, NULL},
	 { (char *)"UserData_memoryAvailable_bytes_get", (PyCFunction)_wrap_UserData_memoryAvailable_bytes_get, METH_O, NULL},
	 { (char *)"UserData_memoryConsumed_bytes_get", (PyCFunction)_wrap_UserData_memoryConsumed_bytes_get, METH_O, NULL},
	 { (char *)"delete_UserData", (PyCFunction)_wrap_delete_UserData, METH_O, NULL},
	 { (char *)"UserData_swigregister", UserData_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Device", (PyCFunction)_wrap_new_Device, METH_O, NULL},
	 { (char *)"delete_Device", (PyCFunction)_wrap_delete_Device, METH_O, NULL},
	 { (char *)"Device_close", (PyCFunction)_wrap_Device_close, METH_O, NULL},
	 { (char *)"Device_hasCapability", _wrap_Device_hasCapability, METH_VARARGS, NULL},
	 { (char *)"Device_hDev", (PyCFunction)_wrap_Device_hDev, METH_O, NULL},
	 { (char *)"Device_hDrv", (PyCFunction)_wrap_Device_hDrv, METH_O, NULL},
	 { (char *)"Device_deviceDriverFeatureList", (PyCFunction)_wrap_Device_deviceDriverFeatureList, METH_O, NULL},
	 { (char *)"Device_getIsOpen", (PyCFunction)_wrap_Device_getIsOpen, METH_O, NULL},
	 { (char *)"Device_isInUse", (PyCFunction)_wrap_Device_isInUse, METH_O, NULL},
	 { (char *)"Device_open", (PyCFunction)_wrap_Device_open, METH_O, NULL},
	 { (char *)"Device_setID", _wrap_Device_setID, METH_VARARGS, NULL},
	 { (char *)"Device_updateFirmware", (PyCFunction)_wrap_Device_updateFirmware, METH_O, NULL},
	 { (char *)"Device_getUserData", (PyCFunction)_wrap_Device_getUserData, METH_O, NULL},
	 { (char *)"Device_validateInterfaceLayout", _wrap_Device_validateInterfaceLayout, METH_VARARGS, NULL},
	 { (char *)"Device_deviceClass_get", (PyCFunction)_wrap_Device_deviceClass_get, METH_O, NULL},
	 { (char *)"Device_family_get", (PyCFunction)_wrap_Device_family_get, METH_O, NULL},
	 { (char *)"Device_product_get", (PyCFunction)_wrap_Device_product_get, METH_O, NULL},
	 { (char *)"Device_capabilities_get", (PyCFunction)_wrap_Device_capabilities_get, METH_O, NULL},
	 { (char *)"Device_serial_get", (PyCFunction)_wrap_Device_serial_get, METH_O, NULL},
	 { (char *)"Device_state_get", (PyCFunction)_wrap_Device_state_get, METH_O, NULL},
	 { (char *)"Device_deviceID_get", (PyCFunction)_wrap_Device_deviceID_get, METH_O, NULL},
	 { (char *)"Device_deviceVersion_get", (PyCFunction)_wrap_Device_deviceVersion_get, METH_O, NULL},
	 { (char *)"Device_firmwareVersion_get", (PyCFunction)_wrap_Device_firmwareVersion_get, METH_O, NULL},
	 { (char *)"Device_loadSettings_get", (PyCFunction)_wrap_Device_loadSettings_get, METH_O, NULL},
	 { (char *)"Device_autoLoadSettingOrder_get", (PyCFunction)_wrap_Device_autoLoadSettingOrder_get, METH_O, NULL},
	 { (char *)"Device_interfaceLayout_get", (PyCFunction)_wrap_Device_interfaceLayout_get, METH_O, NULL},
	 { (char *)"Device_customDataDirectory_get", (PyCFunction)_wrap_Device_customDataDirectory_get, METH_O, NULL},
	 { (char *)"Device_defaultRequestCount_get", (PyCFunction)_wrap_Device_defaultRequestCount_get, METH_O, NULL},
	 { (char *)"Device_resultQueueCount_get", (PyCFunction)_wrap_Device_resultQueueCount_get, METH_O, NULL},
	 { (char *)"Device_userControlledImageProcessingEnable_get", (PyCFunction)_wrap_Device_userControlledImageProcessingEnable_get, METH_O, NULL},
	 { (char *)"Device_allowUnrecommendedFeatures_get", (PyCFunction)_wrap_Device_allowUnrecommendedFeatures_get, METH_O, NULL},
	 { (char *)"Device_acquisitionStartStopBehaviour_get", (PyCFunction)_wrap_Device_acquisitionStartStopBehaviour_get, METH_O, NULL},
	 { (char *)"Device_HWUpdateResult_get", (PyCFunction)_wrap_Device_HWUpdateResult_get, METH_O, NULL},
	 { (char *)"Device_manufacturer_get", (PyCFunction)_wrap_Device_manufacturer_get, METH_O, NULL},
	 { (char *)"Device_manufacturerSpecificInformation_get", (PyCFunction)_wrap_Device_manufacturerSpecificInformation_get, METH_O, NULL},
	 { (char *)"Device_desiredAccess_get", (PyCFunction)_wrap_Device_desiredAccess_get, METH_O, NULL},
	 { (char *)"Device_grantedAccess_get", (PyCFunction)_wrap_Device_grantedAccess_get, METH_O, NULL},
	 { (char *)"Device_swigregister", Device_swigregister, METH_VARARGS, NULL},
	 { (char *)"Device_swiginit", Device_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_DeviceManager", _wrap_new_DeviceManager, METH_VARARGS, NULL},
	 { (char *)"delete_DeviceManager", (PyCFunction)_wrap_delete_DeviceManager, METH_O, NULL},
	 { (char *)"DeviceManager_getVersionAsString", (PyCFunction)_wrap_DeviceManager_getVersionAsString, METH_O, NULL},
	 { (char *)"DeviceManager_changedCount", (PyCFunction)_wrap_DeviceManager_changedCount, METH_O, NULL},
	 { (char *)"DeviceManager_deviceCount", (PyCFunction)_wrap_DeviceManager_deviceCount, METH_O, NULL},
	 { (char *)"DeviceManager_updateDeviceList", (PyCFunction)_wrap_DeviceManager_updateDeviceList, METH_O, NULL},
	 { (char *)"DeviceManager_getDevice", _wrap_DeviceManager_getDevice, METH_VARARGS, NULL},
	 { (char *)"DeviceManager_getDeviceBySerial", _wrap_DeviceManager_getDeviceBySerial, METH_VARARGS, NULL},
	 { (char *)"DeviceManager_getDeviceByFamily", _wrap_DeviceManager_getDeviceByFamily, METH_VARARGS, NULL},
	 { (char *)"DeviceManager_getDeviceByProduct", _wrap_DeviceManager_getDeviceByProduct, METH_VARARGS, NULL},
	 { (char *)"DeviceManager_getDeviceByProductAndID", _wrap_DeviceManager_getDeviceByProductAndID, METH_VARARGS, NULL},
	 { (char *)"DeviceManager_closeAllDevices", (PyCFunction)_wrap_DeviceManager_closeAllDevices, METH_O, NULL},
	 { (char *)"DeviceManager___getitem__", _wrap_DeviceManager___getitem__, METH_VARARGS, NULL},
	 { (char *)"DeviceManager_swigregister", DeviceManager_swigregister, METH_VARARGS, NULL},
	 { (char *)"DeviceManager_swiginit", DeviceManager_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_DeviceComponentLocator", _wrap_new_DeviceComponentLocator, METH_VARARGS, NULL},
	 { (char *)"DeviceComponentLocator_bindSearchBaseList", _wrap_DeviceComponentLocator_bindSearchBaseList, METH_VARARGS, NULL},
	 { (char *)"delete_DeviceComponentLocator", (PyCFunction)_wrap_delete_DeviceComponentLocator, METH_O, NULL},
	 { (char *)"DeviceComponentLocator_swigregister", DeviceComponentLocator_swigregister, METH_VARARGS, NULL},
	 { (char *)"DeviceComponentLocator_swiginit", DeviceComponentLocator_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ImageBufferDesc", _wrap_new_ImageBufferDesc, METH_VARARGS, NULL},
	 { (char *)"delete_ImageBufferDesc", (PyCFunction)_wrap_delete_ImageBufferDesc, METH_O, NULL},
	 { (char *)"ImageBufferDesc_clone", (PyCFunction)_wrap_ImageBufferDesc_clone, METH_O, NULL},
	 { (char *)"ImageBufferDesc_getBuffer", (PyCFunction)_wrap_ImageBufferDesc_getBuffer, METH_O, NULL},
	 { (char *)"ImageBufferDesc_save", _wrap_ImageBufferDesc_save, METH_VARARGS, NULL},
	 { (char *)"ImageBufferDesc_swigregister", ImageBufferDesc_swigregister, METH_VARARGS, NULL},
	 { (char *)"ImageBufferDesc_swiginit", ImageBufferDesc_swiginit, METH_VARARGS, NULL},
	 { (char *)"delete_ComponentCollection", (PyCFunction)_wrap_delete_ComponentCollection, METH_O, NULL},
	 { (char *)"ComponentCollection_hObj", (PyCFunction)_wrap_ComponentCollection_hObj, METH_O, NULL},
	 { (char *)"ComponentCollection_restoreDefault", (PyCFunction)_wrap_ComponentCollection_restoreDefault, METH_O, NULL},
	 { (char *)"ComponentCollection_swigregister", ComponentCollection_swigregister, METH_VARARGS, NULL},
	 { (char *)"BufferPart_getImageBufferDesc", (PyCFunction)_wrap_BufferPart_getImageBufferDesc, METH_O, NULL},
	 { (char *)"BufferPart_address_get", (PyCFunction)_wrap_BufferPart_address_get, METH_O, NULL},
	 { (char *)"BufferPart_dataSize_get", (PyCFunction)_wrap_BufferPart_dataSize_get, METH_O, NULL},
	 { (char *)"BufferPart_dataType_get", (PyCFunction)_wrap_BufferPart_dataType_get, METH_O, NULL},
	 { (char *)"BufferPart_pixelFormat_get", (PyCFunction)_wrap_BufferPart_pixelFormat_get, METH_O, NULL},
	 { (char *)"BufferPart_width_get", (PyCFunction)_wrap_BufferPart_width_get, METH_O, NULL},
	 { (char *)"BufferPart_height_get", (PyCFunction)_wrap_BufferPart_height_get, METH_O, NULL},
	 { (char *)"BufferPart_offsetX_get", (PyCFunction)_wrap_BufferPart_offsetX_get, METH_O, NULL},
	 { (char *)"BufferPart_offsetY_get", (PyCFunction)_wrap_BufferPart_offsetY_get, METH_O, NULL},
	 { (char *)"BufferPart_paddingX_get", (PyCFunction)_wrap_BufferPart_paddingX_get, METH_O, NULL},
	 { (char *)"BufferPart_bytesPerPixel_get", (PyCFunction)_wrap_BufferPart_bytesPerPixel_get, METH_O, NULL},
	 { (char *)"BufferPart_bayerMosaicParity_get", (PyCFunction)_wrap_BufferPart_bayerMosaicParity_get, METH_O, NULL},
	 { (char *)"BufferPart_channelCount_get", (PyCFunction)_wrap_BufferPart_channelCount_get, METH_O, NULL},
	 { (char *)"BufferPart_channelDesc_get", (PyCFunction)_wrap_BufferPart_channelDesc_get, METH_O, NULL},
	 { (char *)"BufferPart_pixelPitch_get", (PyCFunction)_wrap_BufferPart_pixelPitch_get, METH_O, NULL},
	 { (char *)"BufferPart_linePitch_get", (PyCFunction)_wrap_BufferPart_linePitch_get, METH_O, NULL},
	 { (char *)"BufferPart_channelBitDepth_get", (PyCFunction)_wrap_BufferPart_channelBitDepth_get, METH_O, NULL},
	 { (char *)"BufferPart_channelOffset_get", (PyCFunction)_wrap_BufferPart_channelOffset_get, METH_O, NULL},
	 { (char *)"BufferPart_sourceID_get", (PyCFunction)_wrap_BufferPart_sourceID_get, METH_O, NULL},
	 { (char *)"delete_BufferPart", (PyCFunction)_wrap_delete_BufferPart, METH_O, NULL},
	 { (char *)"BufferPart_swigregister", BufferPart_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Request", _wrap_new_Request, METH_VARARGS, NULL},
	 { (char *)"delete_Request", (PyCFunction)_wrap_delete_Request, METH_O, NULL},
	 { (char *)"Request_getComponentLocator", (PyCFunction)_wrap_Request_getComponentLocator, METH_O, NULL},
	 { (char *)"Request_getBufferPartCount", (PyCFunction)_wrap_Request_getBufferPartCount, METH_O, NULL},
	 { (char *)"Request_getBufferPart", _wrap_Request_getBufferPart, METH_VARARGS, NULL},
	 { (char *)"Request_getNumber", (PyCFunction)_wrap_Request_getNumber, METH_O, NULL},
	 { (char *)"Request_getImageBufferDesc", (PyCFunction)_wrap_Request_getImageBufferDesc, METH_O, NULL},
	 { (char *)"Request_getInfoIterator", (PyCFunction)_wrap_Request_getInfoIterator, METH_O, NULL},
	 { (char *)"Request_getImageProcessingResultsIterator", (PyCFunction)_wrap_Request_getImageProcessingResultsIterator, METH_O, NULL},
	 { (char *)"Request_hasProcessingBeenSkipped", (PyCFunction)_wrap_Request_hasProcessingBeenSkipped, METH_O, NULL},
	 { (char *)"Request_getChunkCounterCount", (PyCFunction)_wrap_Request_getChunkCounterCount, METH_O, NULL},
	 { (char *)"Request_getChunkTimerCount", (PyCFunction)_wrap_Request_getChunkTimerCount, METH_O, NULL},
	 { (char *)"Request_getChunkTimerValue", _wrap_Request_getChunkTimerValue, METH_VARARGS, NULL},
	 { (char *)"Request_getChunkGainCount", (PyCFunction)_wrap_Request_getChunkGainCount, METH_O, NULL},
	 { (char *)"Request_getChunkGain", _wrap_Request_getChunkGain, METH_VARARGS, NULL},
	 { (char *)"Request_isOK", (PyCFunction)_wrap_Request_isOK, METH_O, NULL},
	 { (char *)"Request_configure", (PyCFunction)_wrap_Request_configure, METH_O, NULL},
	 { (char *)"Request_save", _wrap_Request_save, METH_VARARGS, NULL},
	 { (char *)"Request_unlock", (PyCFunction)_wrap_Request_unlock, METH_O, NULL},
	 { (char *)"Request_attachUserBuffer", _wrap_Request_attachUserBuffer, METH_VARARGS, NULL},
	 { (char *)"Request_detachUserBuffer", (PyCFunction)_wrap_Request_detachUserBuffer, METH_O, NULL},
	 { (char *)"Request_requestResult_get", (PyCFunction)_wrap_Request_requestResult_get, METH_O, NULL},
	 { (char *)"Request_requestState_get", (PyCFunction)_wrap_Request_requestState_get, METH_O, NULL},
	 { (char *)"Request_infoFrameID_get", (PyCFunction)_wrap_Request_infoFrameID_get, METH_O, NULL},
	 { (char *)"Request_infoFrameNr_get", (PyCFunction)_wrap_Request_infoFrameNr_get, METH_O, NULL},
	 { (char *)"Request_infoExposeStart_us_get", (PyCFunction)_wrap_Request_infoExposeStart_us_get, METH_O, NULL},
	 { (char *)"Request_infoExposeTime_us_get", (PyCFunction)_wrap_Request_infoExposeTime_us_get, METH_O, NULL},
	 { (char *)"Request_infoTransferDelay_us_get", (PyCFunction)_wrap_Request_infoTransferDelay_us_get, METH_O, NULL},
	 { (char *)"Request_infoGain_dB_get", (PyCFunction)_wrap_Request_infoGain_dB_get, METH_O, NULL},
	 { (char *)"Request_infoTimeStamp_us_get", (PyCFunction)_wrap_Request_infoTimeStamp_us_get, METH_O, NULL},
	 { (char *)"Request_infoSettingUsed_get", (PyCFunction)_wrap_Request_infoSettingUsed_get, METH_O, NULL},
	 { (char *)"Request_infoImageAverage_get", (PyCFunction)_wrap_Request_infoImageAverage_get, METH_O, NULL},
	 { (char *)"Request_infoVideoChannel_get", (PyCFunction)_wrap_Request_infoVideoChannel_get, METH_O, NULL},
	 { (char *)"Request_infoCameraOutputUsed_get", (PyCFunction)_wrap_Request_infoCameraOutputUsed_get, METH_O, NULL},
	 { (char *)"Request_infoLineCounter_get", (PyCFunction)_wrap_Request_infoLineCounter_get, METH_O, NULL},
	 { (char *)"Request_infoMissingData_pc_get", (PyCFunction)_wrap_Request_infoMissingData_pc_get, METH_O, NULL},
	 { (char *)"Request_infoIOStatesAtExposureStart_get", (PyCFunction)_wrap_Request_infoIOStatesAtExposureStart_get, METH_O, NULL},
	 { (char *)"Request_infoIOStatesAtExposureEnd_get", (PyCFunction)_wrap_Request_infoIOStatesAtExposureEnd_get, METH_O, NULL},
	 { (char *)"Request_chunkOffsetX_get", (PyCFunction)_wrap_Request_chunkOffsetX_get, METH_O, NULL},
	 { (char *)"Request_chunkOffsetY_get", (PyCFunction)_wrap_Request_chunkOffsetY_get, METH_O, NULL},
	 { (char *)"Request_chunkWidth_get", (PyCFunction)_wrap_Request_chunkWidth_get, METH_O, NULL},
	 { (char *)"Request_chunkHeight_get", (PyCFunction)_wrap_Request_chunkHeight_get, METH_O, NULL},
	 { (char *)"Request_chunkPixelFormat_get", (PyCFunction)_wrap_Request_chunkPixelFormat_get, METH_O, NULL},
	 { (char *)"Request_chunkDynamicRangeMin_get", (PyCFunction)_wrap_Request_chunkDynamicRangeMin_get, METH_O, NULL},
	 { (char *)"Request_chunkDynamicRangeMax_get", (PyCFunction)_wrap_Request_chunkDynamicRangeMax_get, METH_O, NULL},
	 { (char *)"Request_chunkExposureTime_get", (PyCFunction)_wrap_Request_chunkExposureTime_get, METH_O, NULL},
	 { (char *)"Request_chunkTimestamp_get", (PyCFunction)_wrap_Request_chunkTimestamp_get, METH_O, NULL},
	 { (char *)"Request_chunkLineStatusAll_get", (PyCFunction)_wrap_Request_chunkLineStatusAll_get, METH_O, NULL},
	 { (char *)"Request_chunkSequencerSetActive_get", (PyCFunction)_wrap_Request_chunkSequencerSetActive_get, METH_O, NULL},
	 { (char *)"Request_chunkmvCustomIdentifier_get", (PyCFunction)_wrap_Request_chunkmvCustomIdentifier_get, METH_O, NULL},
	 { (char *)"Request_imageMemoryMode_get", (PyCFunction)_wrap_Request_imageMemoryMode_get, METH_O, NULL},
	 { (char *)"Request_imagePixelFormat_get", (PyCFunction)_wrap_Request_imagePixelFormat_get, METH_O, NULL},
	 { (char *)"Request_imageData_get", (PyCFunction)_wrap_Request_imageData_get, METH_O, NULL},
	 { (char *)"Request_imageSize_get", (PyCFunction)_wrap_Request_imageSize_get, METH_O, NULL},
	 { (char *)"Request_imageFooter_get", (PyCFunction)_wrap_Request_imageFooter_get, METH_O, NULL},
	 { (char *)"Request_imageFooterSize_get", (PyCFunction)_wrap_Request_imageFooterSize_get, METH_O, NULL},
	 { (char *)"Request_imagePixelPitch_get", (PyCFunction)_wrap_Request_imagePixelPitch_get, METH_O, NULL},
	 { (char *)"Request_imageChannelCount_get", (PyCFunction)_wrap_Request_imageChannelCount_get, METH_O, NULL},
	 { (char *)"Request_imageChannelOffset_get", (PyCFunction)_wrap_Request_imageChannelOffset_get, METH_O, NULL},
	 { (char *)"Request_imageChannelBitDepth_get", (PyCFunction)_wrap_Request_imageChannelBitDepth_get, METH_O, NULL},
	 { (char *)"Request_imageLinePitch_get", (PyCFunction)_wrap_Request_imageLinePitch_get, METH_O, NULL},
	 { (char *)"Request_imageChannelDesc_get", (PyCFunction)_wrap_Request_imageChannelDesc_get, METH_O, NULL},
	 { (char *)"Request_imageBytesPerPixel_get", (PyCFunction)_wrap_Request_imageBytesPerPixel_get, METH_O, NULL},
	 { (char *)"Request_imageOffsetX_get", (PyCFunction)_wrap_Request_imageOffsetX_get, METH_O, NULL},
	 { (char *)"Request_imageOffsetY_get", (PyCFunction)_wrap_Request_imageOffsetY_get, METH_O, NULL},
	 { (char *)"Request_imageWidth_get", (PyCFunction)_wrap_Request_imageWidth_get, METH_O, NULL},
	 { (char *)"Request_imageWidthTotal_get", (PyCFunction)_wrap_Request_imageWidthTotal_get, METH_O, NULL},
	 { (char *)"Request_imageHeight_get", (PyCFunction)_wrap_Request_imageHeight_get, METH_O, NULL},
	 { (char *)"Request_imageHeightTotal_get", (PyCFunction)_wrap_Request_imageHeightTotal_get, METH_O, NULL},
	 { (char *)"Request_imageBayerMosaicParity_get", (PyCFunction)_wrap_Request_imageBayerMosaicParity_get, METH_O, NULL},
	 { (char *)"Request_swigregister", Request_swigregister, METH_VARARGS, NULL},
	 { (char *)"Request_swiginit", Request_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ImageRequestControl", _wrap_new_ImageRequestControl, METH_VARARGS, NULL},
	 { (char *)"ImageRequestControl_mode_get", (PyCFunction)_wrap_ImageRequestControl_mode_get, METH_O, NULL},
	 { (char *)"ImageRequestControl_imageCount_get", (PyCFunction)_wrap_ImageRequestControl_imageCount_get, METH_O, NULL},
	 { (char *)"ImageRequestControl_setting_get", (PyCFunction)_wrap_ImageRequestControl_setting_get, METH_O, NULL},
	 { (char *)"ImageRequestControl_resultQueue_get", (PyCFunction)_wrap_ImageRequestControl_resultQueue_get, METH_O, NULL},
	 { (char *)"ImageRequestControl_requestToUse_get", (PyCFunction)_wrap_ImageRequestControl_requestToUse_get, METH_O, NULL},
	 { (char *)"delete_ImageRequestControl", (PyCFunction)_wrap_delete_ImageRequestControl, METH_O, NULL},
	 { (char *)"ImageRequestControl_swigregister", ImageRequestControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"ImageRequestControl_swiginit", ImageRequestControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"delete_RequestFactory", (PyCFunction)_wrap_delete_RequestFactory, METH_O, NULL},
	 { (char *)"RequestFactory_createRequest", _wrap_RequestFactory_createRequest, METH_VARARGS, NULL},
	 { (char *)"new_RequestFactory", (PyCFunction)_wrap_new_RequestFactory, METH_NOARGS, NULL},
	 { (char *)"RequestFactory_swigregister", RequestFactory_swigregister, METH_VARARGS, NULL},
	 { (char *)"RequestFactory_swiginit", RequestFactory_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_FunctionInterface", _wrap_new_FunctionInterface, METH_VARARGS, NULL},
	 { (char *)"delete_FunctionInterface", (PyCFunction)_wrap_delete_FunctionInterface, METH_O, NULL},
	 { (char *)"FunctionInterface_acquisitionStart", (PyCFunction)_wrap_FunctionInterface_acquisitionStart, METH_O, NULL},
	 { (char *)"FunctionInterface_acquisitionStop", (PyCFunction)_wrap_FunctionInterface_acquisitionStop, METH_O, NULL},
	 { (char *)"FunctionInterface_createImageRequestControl", _wrap_FunctionInterface_createImageRequestControl, METH_VARARGS, NULL},
	 { (char *)"FunctionInterface_createSetting", _wrap_FunctionInterface_createSetting, METH_VARARGS, NULL},
	 { (char *)"FunctionInterface_deleteSettingFromStack", (PyCFunction)_wrap_FunctionInterface_deleteSettingFromStack, METH_O, NULL},
	 { (char *)"FunctionInterface_deleteSetting", _wrap_FunctionInterface_deleteSetting, METH_VARARGS, NULL},
	 { (char *)"FunctionInterface_getAvailableSettings", (PyCFunction)_wrap_FunctionInterface_getAvailableSettings, METH_O, NULL},
	 { (char *)"FunctionInterface_getAvailableImageRequestControls", (PyCFunction)_wrap_FunctionInterface_getAvailableImageRequestControls, METH_O, NULL},
	 { (char *)"FunctionInterface_getRequest", _wrap_FunctionInterface_getRequest, METH_VARARGS, NULL},
	 { (char *)"FunctionInterface_getSetting", _wrap_FunctionInterface_getSetting, METH_VARARGS, NULL},
	 { (char *)"FunctionInterface_imageRequestConfigure", _wrap_FunctionInterface_imageRequestConfigure, METH_VARARGS, NULL},
	 { (char *)"FunctionInterface_imageRequestResultQueueElementCount", _wrap_FunctionInterface_imageRequestResultQueueElementCount, METH_VARARGS, NULL},
	 { (char *)"FunctionInterface_imageRequestReset", _wrap_FunctionInterface_imageRequestReset, METH_VARARGS, NULL},
	 { (char *)"FunctionInterface_imageRequestSingle", _wrap_FunctionInterface_imageRequestSingle, METH_VARARGS, NULL},
	 { (char *)"FunctionInterface_imageRequestUnlock", _wrap_FunctionInterface_imageRequestUnlock, METH_VARARGS, NULL},
	 { (char *)"FunctionInterface_imageRequestWaitFor", _wrap_FunctionInterface_imageRequestWaitFor, METH_VARARGS, NULL},
	 { (char *)"FunctionInterface_getCurrentCaptureBufferLayout", _wrap_FunctionInterface_getCurrentCaptureBufferLayout, METH_VARARGS, NULL},
	 { (char *)"FunctionInterface_isRequestNrValid", _wrap_FunctionInterface_isRequestNrValid, METH_VARARGS, NULL},
	 { (char *)"FunctionInterface_isSettingAvailable", _wrap_FunctionInterface_isSettingAvailable, METH_VARARGS, NULL},
	 { (char *)"FunctionInterface_loadSetting", _wrap_FunctionInterface_loadSetting, METH_VARARGS, NULL},
	 { (char *)"FunctionInterface_loadSettingFromStack", (PyCFunction)_wrap_FunctionInterface_loadSettingFromStack, METH_O, NULL},
	 { (char *)"FunctionInterface_loadAndDeleteSettingFromStack", (PyCFunction)_wrap_FunctionInterface_loadAndDeleteSettingFromStack, METH_O, NULL},
	 { (char *)"FunctionInterface_loadSettingFromDefault", _wrap_FunctionInterface_loadSettingFromDefault, METH_VARARGS, NULL},
	 { (char *)"FunctionInterface_requestCount", (PyCFunction)_wrap_FunctionInterface_requestCount, METH_O, NULL},
	 { (char *)"FunctionInterface_saveCurrentSettingOnStack", _wrap_FunctionInterface_saveCurrentSettingOnStack, METH_VARARGS, NULL},
	 { (char *)"FunctionInterface_saveSetting", _wrap_FunctionInterface_saveSetting, METH_VARARGS, NULL},
	 { (char *)"FunctionInterface_saveSettingToDefault", _wrap_FunctionInterface_saveSettingToDefault, METH_VARARGS, NULL},
	 { (char *)"FunctionInterface_swigregister", FunctionInterface_swigregister, METH_VARARGS, NULL},
	 { (char *)"FunctionInterface_swiginit", FunctionInterface_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_Info", (PyCFunction)_wrap_new_Info, METH_O, NULL},
	 { (char *)"Info_deviceDriverVersion_get", (PyCFunction)_wrap_Info_deviceDriverVersion_get, METH_O, NULL},
	 { (char *)"Info_driverDate_get", (PyCFunction)_wrap_Info_driverDate_get, METH_O, NULL},
	 { (char *)"Info_driverVersion_get", (PyCFunction)_wrap_Info_driverVersion_get, METH_O, NULL},
	 { (char *)"Info_state_get", (PyCFunction)_wrap_Info_state_get, METH_O, NULL},
	 { (char *)"Info_loadedSettings_get", (PyCFunction)_wrap_Info_loadedSettings_get, METH_O, NULL},
	 { (char *)"Info_logFile_get", (PyCFunction)_wrap_Info_logFile_get, METH_O, NULL},
	 { (char *)"Info_captureBufferAlignment_get", (PyCFunction)_wrap_Info_captureBufferAlignment_get, METH_O, NULL},
	 { (char *)"Info_recommendedListsForUIs_get", (PyCFunction)_wrap_Info_recommendedListsForUIs_get, METH_O, NULL},
	 { (char *)"delete_Info", (PyCFunction)_wrap_delete_Info, METH_O, NULL},
	 { (char *)"Info_swigregister", Info_swigregister, METH_VARARGS, NULL},
	 { (char *)"Info_swiginit", Info_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_BasicDeviceSettings", _wrap_new_BasicDeviceSettings, METH_VARARGS, NULL},
	 { (char *)"BasicDeviceSettings_basedOn_get", (PyCFunction)_wrap_BasicDeviceSettings_basedOn_get, METH_O, NULL},
	 { (char *)"BasicDeviceSettings_imageRequestTimeout_ms_get", (PyCFunction)_wrap_BasicDeviceSettings_imageRequestTimeout_ms_get, METH_O, NULL},
	 { (char *)"delete_BasicDeviceSettings", (PyCFunction)_wrap_delete_BasicDeviceSettings, METH_O, NULL},
	 { (char *)"BasicDeviceSettings_swigregister", BasicDeviceSettings_swigregister, METH_VARARGS, NULL},
	 { (char *)"BasicDeviceSettings_swiginit", BasicDeviceSettings_swiginit, METH_VARARGS, NULL},
	 { (char *)"TriggerControl_getDescription", (PyCFunction)_wrap_TriggerControl_getDescription, METH_O, NULL},
	 { (char *)"TriggerControl_triggerSoftware", (PyCFunction)_wrap_TriggerControl_triggerSoftware, METH_O, NULL},
	 { (char *)"TriggerControl_triggerMode_get", (PyCFunction)_wrap_TriggerControl_triggerMode_get, METH_O, NULL},
	 { (char *)"TriggerControl_triggerSource_get", (PyCFunction)_wrap_TriggerControl_triggerSource_get, METH_O, NULL},
	 { (char *)"TriggerControl_triggerActivation_get", (PyCFunction)_wrap_TriggerControl_triggerActivation_get, METH_O, NULL},
	 { (char *)"TriggerControl_triggerDivider_get", (PyCFunction)_wrap_TriggerControl_triggerDivider_get, METH_O, NULL},
	 { (char *)"TriggerControl_triggerDelayAbs_us_get", (PyCFunction)_wrap_TriggerControl_triggerDelayAbs_us_get, METH_O, NULL},
	 { (char *)"TriggerControl_triggerDelayLines_get", (PyCFunction)_wrap_TriggerControl_triggerDelayLines_get, METH_O, NULL},
	 { (char *)"TriggerControl_triggerOverlap_get", (PyCFunction)_wrap_TriggerControl_triggerOverlap_get, METH_O, NULL},
	 { (char *)"delete_TriggerControl", (PyCFunction)_wrap_delete_TriggerControl, METH_O, NULL},
	 { (char *)"TriggerControl_swigregister", TriggerControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ImageDestination", _wrap_new_ImageDestination, METH_VARARGS, NULL},
	 { (char *)"ImageDestination_pixelFormat_get", (PyCFunction)_wrap_ImageDestination_pixelFormat_get, METH_O, NULL},
	 { (char *)"ImageDestination_scalerMode_get", (PyCFunction)_wrap_ImageDestination_scalerMode_get, METH_O, NULL},
	 { (char *)"ImageDestination_scalerInterpolationMode_get", (PyCFunction)_wrap_ImageDestination_scalerInterpolationMode_get, METH_O, NULL},
	 { (char *)"ImageDestination_scalerAoiEnable_get", (PyCFunction)_wrap_ImageDestination_scalerAoiEnable_get, METH_O, NULL},
	 { (char *)"ImageDestination_scalerAoiHeight_get", (PyCFunction)_wrap_ImageDestination_scalerAoiHeight_get, METH_O, NULL},
	 { (char *)"ImageDestination_scalerAoiStartX_get", (PyCFunction)_wrap_ImageDestination_scalerAoiStartX_get, METH_O, NULL},
	 { (char *)"ImageDestination_scalerAoiStartY_get", (PyCFunction)_wrap_ImageDestination_scalerAoiStartY_get, METH_O, NULL},
	 { (char *)"ImageDestination_scalerAoiWidth_get", (PyCFunction)_wrap_ImageDestination_scalerAoiWidth_get, METH_O, NULL},
	 { (char *)"ImageDestination_imageWidth_get", (PyCFunction)_wrap_ImageDestination_imageWidth_get, METH_O, NULL},
	 { (char *)"ImageDestination_imageHeight_get", (PyCFunction)_wrap_ImageDestination_imageHeight_get, METH_O, NULL},
	 { (char *)"delete_ImageDestination", (PyCFunction)_wrap_delete_ImageDestination, METH_O, NULL},
	 { (char *)"ImageDestination_swigregister", ImageDestination_swigregister, METH_VARARGS, NULL},
	 { (char *)"ImageDestination_swiginit", ImageDestination_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_RequestInfoConfiguration", _wrap_new_RequestInfoConfiguration, METH_VARARGS, NULL},
	 { (char *)"RequestInfoConfiguration_frameNr_get", (PyCFunction)_wrap_RequestInfoConfiguration_frameNr_get, METH_O, NULL},
	 { (char *)"RequestInfoConfiguration_timeStamp_us_get", (PyCFunction)_wrap_RequestInfoConfiguration_timeStamp_us_get, METH_O, NULL},
	 { (char *)"RequestInfoConfiguration_settingUsed_get", (PyCFunction)_wrap_RequestInfoConfiguration_settingUsed_get, METH_O, NULL},
	 { (char *)"RequestInfoConfiguration_frameID_get", (PyCFunction)_wrap_RequestInfoConfiguration_frameID_get, METH_O, NULL},
	 { (char *)"RequestInfoConfiguration_exposeStart_us_get", (PyCFunction)_wrap_RequestInfoConfiguration_exposeStart_us_get, METH_O, NULL},
	 { (char *)"RequestInfoConfiguration_exposeTime_us_get", (PyCFunction)_wrap_RequestInfoConfiguration_exposeTime_us_get, METH_O, NULL},
	 { (char *)"RequestInfoConfiguration_gain_dB_get", (PyCFunction)_wrap_RequestInfoConfiguration_gain_dB_get, METH_O, NULL},
	 { (char *)"RequestInfoConfiguration_videoChannel_get", (PyCFunction)_wrap_RequestInfoConfiguration_videoChannel_get, METH_O, NULL},
	 { (char *)"RequestInfoConfiguration_missingData_pc_get", (PyCFunction)_wrap_RequestInfoConfiguration_missingData_pc_get, METH_O, NULL},
	 { (char *)"RequestInfoConfiguration_transferDelay_us_get", (PyCFunction)_wrap_RequestInfoConfiguration_transferDelay_us_get, METH_O, NULL},
	 { (char *)"RequestInfoConfiguration_imageAverage_get", (PyCFunction)_wrap_RequestInfoConfiguration_imageAverage_get, METH_O, NULL},
	 { (char *)"RequestInfoConfiguration_IOStatesAtExposureStart_get", (PyCFunction)_wrap_RequestInfoConfiguration_IOStatesAtExposureStart_get, METH_O, NULL},
	 { (char *)"RequestInfoConfiguration_triggerCounterAcquisitionStart_get", (PyCFunction)_wrap_RequestInfoConfiguration_triggerCounterAcquisitionStart_get, METH_O, NULL},
	 { (char *)"RequestInfoConfiguration_triggerCounterFrameStart_get", (PyCFunction)_wrap_RequestInfoConfiguration_triggerCounterFrameStart_get, METH_O, NULL},
	 { (char *)"RequestInfoConfiguration_lineCounter_get", (PyCFunction)_wrap_RequestInfoConfiguration_lineCounter_get, METH_O, NULL},
	 { (char *)"RequestInfoConfiguration_userData_get", (PyCFunction)_wrap_RequestInfoConfiguration_userData_get, METH_O, NULL},
	 { (char *)"RequestInfoConfiguration_lineStatusAll_get", (PyCFunction)_wrap_RequestInfoConfiguration_lineStatusAll_get, METH_O, NULL},
	 { (char *)"delete_RequestInfoConfiguration", (PyCFunction)_wrap_delete_RequestInfoConfiguration, METH_O, NULL},
	 { (char *)"RequestInfoConfiguration_swigregister", RequestInfoConfiguration_swigregister, METH_VARARGS, NULL},
	 { (char *)"RequestInfoConfiguration_swiginit", RequestInfoConfiguration_swiginit, METH_VARARGS, NULL},
	 { (char *)"WhiteBalanceSettings_WBAoiMode_get", (PyCFunction)_wrap_WhiteBalanceSettings_WBAoiMode_get, METH_O, NULL},
	 { (char *)"WhiteBalanceSettings_aoiHeight_get", (PyCFunction)_wrap_WhiteBalanceSettings_aoiHeight_get, METH_O, NULL},
	 { (char *)"WhiteBalanceSettings_aoiStartX_get", (PyCFunction)_wrap_WhiteBalanceSettings_aoiStartX_get, METH_O, NULL},
	 { (char *)"WhiteBalanceSettings_aoiStartY_get", (PyCFunction)_wrap_WhiteBalanceSettings_aoiStartY_get, METH_O, NULL},
	 { (char *)"WhiteBalanceSettings_aoiWidth_get", (PyCFunction)_wrap_WhiteBalanceSettings_aoiWidth_get, METH_O, NULL},
	 { (char *)"WhiteBalanceSettings_totalGain_get", (PyCFunction)_wrap_WhiteBalanceSettings_totalGain_get, METH_O, NULL},
	 { (char *)"WhiteBalanceSettings_redGain_get", (PyCFunction)_wrap_WhiteBalanceSettings_redGain_get, METH_O, NULL},
	 { (char *)"WhiteBalanceSettings_greenGain_get", (PyCFunction)_wrap_WhiteBalanceSettings_greenGain_get, METH_O, NULL},
	 { (char *)"WhiteBalanceSettings_blueGain_get", (PyCFunction)_wrap_WhiteBalanceSettings_blueGain_get, METH_O, NULL},
	 { (char *)"WhiteBalanceSettings_WBResult_get", (PyCFunction)_wrap_WhiteBalanceSettings_WBResult_get, METH_O, NULL},
	 { (char *)"delete_WhiteBalanceSettings", (PyCFunction)_wrap_delete_WhiteBalanceSettings, METH_O, NULL},
	 { (char *)"WhiteBalanceSettings_swigregister", WhiteBalanceSettings_swigregister, METH_VARARGS, NULL},
	 { (char *)"GainOffsetKneeChannelParameters_gain_get", (PyCFunction)_wrap_GainOffsetKneeChannelParameters_gain_get, METH_O, NULL},
	 { (char *)"GainOffsetKneeChannelParameters_offset_pc_get", (PyCFunction)_wrap_GainOffsetKneeChannelParameters_offset_pc_get, METH_O, NULL},
	 { (char *)"delete_GainOffsetKneeChannelParameters", (PyCFunction)_wrap_delete_GainOffsetKneeChannelParameters, METH_O, NULL},
	 { (char *)"GainOffsetKneeChannelParameters_swigregister", GainOffsetKneeChannelParameters_swigregister, METH_VARARGS, NULL},
	 { (char *)"LUTParameters_gamma_get", (PyCFunction)_wrap_LUTParameters_gamma_get, METH_O, NULL},
	 { (char *)"LUTParameters_gammaAlpha_get", (PyCFunction)_wrap_LUTParameters_gammaAlpha_get, METH_O, NULL},
	 { (char *)"LUTParameters_gammaMode_get", (PyCFunction)_wrap_LUTParameters_gammaMode_get, METH_O, NULL},
	 { (char *)"LUTParameters_gammaStartThreshold_get", (PyCFunction)_wrap_LUTParameters_gammaStartThreshold_get, METH_O, NULL},
	 { (char *)"LUTParameters_valueCount_get", (PyCFunction)_wrap_LUTParameters_valueCount_get, METH_O, NULL},
	 { (char *)"LUTParameters_inputValues_get", (PyCFunction)_wrap_LUTParameters_inputValues_get, METH_O, NULL},
	 { (char *)"LUTParameters_outputValues_get", (PyCFunction)_wrap_LUTParameters_outputValues_get, METH_O, NULL},
	 { (char *)"LUTParameters_directValues_get", (PyCFunction)_wrap_LUTParameters_directValues_get, METH_O, NULL},
	 { (char *)"delete_LUTParameters", (PyCFunction)_wrap_delete_LUTParameters, METH_O, NULL},
	 { (char *)"LUTParameters_swigregister", LUTParameters_swigregister, METH_VARARGS, NULL},
	 { (char *)"MirrorParameters_mirrorMode_get", (PyCFunction)_wrap_MirrorParameters_mirrorMode_get, METH_O, NULL},
	 { (char *)"delete_MirrorParameters", (PyCFunction)_wrap_delete_MirrorParameters, METH_O, NULL},
	 { (char *)"MirrorParameters_swigregister", MirrorParameters_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ImageProcessing", _wrap_new_ImageProcessing, METH_VARARGS, NULL},
	 { (char *)"delete_ImageProcessing", (PyCFunction)_wrap_delete_ImageProcessing, METH_O, NULL},
	 { (char *)"ImageProcessing_colorProcessing_get", (PyCFunction)_wrap_ImageProcessing_colorProcessing_get, METH_O, NULL},
	 { (char *)"ImageProcessing_bayerConversionMode_get", (PyCFunction)_wrap_ImageProcessing_bayerConversionMode_get, METH_O, NULL},
	 { (char *)"ImageProcessing_adaptiveEdgeSensingPlusSharpenThreshold_get", (PyCFunction)_wrap_ImageProcessing_adaptiveEdgeSensingPlusSharpenThreshold_get, METH_O, NULL},
	 { (char *)"ImageProcessing_adaptiveEdgeSensingPlusSharpenGain_get", (PyCFunction)_wrap_ImageProcessing_adaptiveEdgeSensingPlusSharpenGain_get, METH_O, NULL},
	 { (char *)"ImageProcessing_whiteBalance_get", (PyCFunction)_wrap_ImageProcessing_whiteBalance_get, METH_O, NULL},
	 { (char *)"ImageProcessing_whiteBalanceCalibration_get", (PyCFunction)_wrap_ImageProcessing_whiteBalanceCalibration_get, METH_O, NULL},
	 { (char *)"ImageProcessing_filter_get", (PyCFunction)_wrap_ImageProcessing_filter_get, METH_O, NULL},
	 { (char *)"ImageProcessing_mirrorOperationMode_get", (PyCFunction)_wrap_ImageProcessing_mirrorOperationMode_get, METH_O, NULL},
	 { (char *)"ImageProcessing_mirrorModeGlobal_get", (PyCFunction)_wrap_ImageProcessing_mirrorModeGlobal_get, METH_O, NULL},
	 { (char *)"ImageProcessing_polarizedDataExtractionEnable_get", (PyCFunction)_wrap_ImageProcessing_polarizedDataExtractionEnable_get, METH_O, NULL},
	 { (char *)"ImageProcessing_polarizedDataExtractionMode_get", (PyCFunction)_wrap_ImageProcessing_polarizedDataExtractionMode_get, METH_O, NULL},
	 { (char *)"ImageProcessing_polarizedDataExtractionInterpolationMode_get", (PyCFunction)_wrap_ImageProcessing_polarizedDataExtractionInterpolationMode_get, METH_O, NULL},
	 { (char *)"ImageProcessing_polarizedDataExtractionChannelIndex_get", (PyCFunction)_wrap_ImageProcessing_polarizedDataExtractionChannelIndex_get, METH_O, NULL},
	 { (char *)"ImageProcessing_polarizedDataExtractionLowerLimit_get", (PyCFunction)_wrap_ImageProcessing_polarizedDataExtractionLowerLimit_get, METH_O, NULL},
	 { (char *)"ImageProcessing_polarizedDataExtractionUpperLimit_get", (PyCFunction)_wrap_ImageProcessing_polarizedDataExtractionUpperLimit_get, METH_O, NULL},
	 { (char *)"ImageProcessing_defectivePixelsFilterMode_get", (PyCFunction)_wrap_ImageProcessing_defectivePixelsFilterMode_get, METH_O, NULL},
	 { (char *)"ImageProcessing_defectivePixelsFilterLeakyPixelDeviation_ADCLimit_get", (PyCFunction)_wrap_ImageProcessing_defectivePixelsFilterLeakyPixelDeviation_ADCLimit_get, METH_O, NULL},
	 { (char *)"ImageProcessing_defectivePixelsFilterColdPixelDeviation_pc_get", (PyCFunction)_wrap_ImageProcessing_defectivePixelsFilterColdPixelDeviation_pc_get, METH_O, NULL},
	 { (char *)"ImageProcessing_defectivePixelsFound_get", (PyCFunction)_wrap_ImageProcessing_defectivePixelsFound_get, METH_O, NULL},
	 { (char *)"ImageProcessing_defectivePixelOffsetX_get", (PyCFunction)_wrap_ImageProcessing_defectivePixelOffsetX_get, METH_O, NULL},
	 { (char *)"ImageProcessing_defectivePixelOffsetY_get", (PyCFunction)_wrap_ImageProcessing_defectivePixelOffsetY_get, METH_O, NULL},
	 { (char *)"ImageProcessing_defectivePixelReadFromDevice_get", (PyCFunction)_wrap_ImageProcessing_defectivePixelReadFromDevice_get, METH_O, NULL},
	 { (char *)"ImageProcessing_defectivePixelWriteToDevice_get", (PyCFunction)_wrap_ImageProcessing_defectivePixelWriteToDevice_get, METH_O, NULL},
	 { (char *)"ImageProcessing_flatFieldFilterCorrectionMode_get", (PyCFunction)_wrap_ImageProcessing_flatFieldFilterCorrectionMode_get, METH_O, NULL},
	 { (char *)"ImageProcessing_flatFieldFilterMode_get", (PyCFunction)_wrap_ImageProcessing_flatFieldFilterMode_get, METH_O, NULL},
	 { (char *)"ImageProcessing_flatFieldFilterCalibrationImageCount_get", (PyCFunction)_wrap_ImageProcessing_flatFieldFilterCalibrationImageCount_get, METH_O, NULL},
	 { (char *)"ImageProcessing_darkCurrentFilterMode_get", (PyCFunction)_wrap_ImageProcessing_darkCurrentFilterMode_get, METH_O, NULL},
	 { (char *)"ImageProcessing_darkCurrentFilterCalibrationImageCount_get", (PyCFunction)_wrap_ImageProcessing_darkCurrentFilterCalibrationImageCount_get, METH_O, NULL},
	 { (char *)"ImageProcessing_gainOffsetKneeEnable_get", (PyCFunction)_wrap_ImageProcessing_gainOffsetKneeEnable_get, METH_O, NULL},
	 { (char *)"ImageProcessing_gainOffsetKneeMasterOffset_pc_get", (PyCFunction)_wrap_ImageProcessing_gainOffsetKneeMasterOffset_pc_get, METH_O, NULL},
	 { (char *)"ImageProcessing_LUTEnable_get", (PyCFunction)_wrap_ImageProcessing_LUTEnable_get, METH_O, NULL},
	 { (char *)"ImageProcessing_LUTMode_get", (PyCFunction)_wrap_ImageProcessing_LUTMode_get, METH_O, NULL},
	 { (char *)"ImageProcessing_LUTInterpolationMode_get", (PyCFunction)_wrap_ImageProcessing_LUTInterpolationMode_get, METH_O, NULL},
	 { (char *)"ImageProcessing_LUTImplementation_get", (PyCFunction)_wrap_ImageProcessing_LUTImplementation_get, METH_O, NULL},
	 { (char *)"ImageProcessing_LUTMappingHardware_get", (PyCFunction)_wrap_ImageProcessing_LUTMappingHardware_get, METH_O, NULL},
	 { (char *)"ImageProcessing_LUTMappingSoftware_get", (PyCFunction)_wrap_ImageProcessing_LUTMappingSoftware_get, METH_O, NULL},
	 { (char *)"ImageProcessing_tapSortEnable_get", (PyCFunction)_wrap_ImageProcessing_tapSortEnable_get, METH_O, NULL},
	 { (char *)"ImageProcessing_channelSplitEnable_get", (PyCFunction)_wrap_ImageProcessing_channelSplitEnable_get, METH_O, NULL},
	 { (char *)"ImageProcessing_channelSplitMode_get", (PyCFunction)_wrap_ImageProcessing_channelSplitMode_get, METH_O, NULL},
	 { (char *)"ImageProcessing_channelSplitChannelIndex_get", (PyCFunction)_wrap_ImageProcessing_channelSplitChannelIndex_get, METH_O, NULL},
	 { (char *)"ImageProcessing_channelSplitDeinterlaceEnable_get", (PyCFunction)_wrap_ImageProcessing_channelSplitDeinterlaceEnable_get, METH_O, NULL},
	 { (char *)"ImageProcessing_colorTwistInputCorrectionMatrixEnable_get", (PyCFunction)_wrap_ImageProcessing_colorTwistInputCorrectionMatrixEnable_get, METH_O, NULL},
	 { (char *)"ImageProcessing_colorTwistInputCorrectionMatrixMode_get", (PyCFunction)_wrap_ImageProcessing_colorTwistInputCorrectionMatrixMode_get, METH_O, NULL},
	 { (char *)"ImageProcessing_colorTwistInputCorrectionMatrixRow0_get", (PyCFunction)_wrap_ImageProcessing_colorTwistInputCorrectionMatrixRow0_get, METH_O, NULL},
	 { (char *)"ImageProcessing_colorTwistInputCorrectionMatrixRow1_get", (PyCFunction)_wrap_ImageProcessing_colorTwistInputCorrectionMatrixRow1_get, METH_O, NULL},
	 { (char *)"ImageProcessing_colorTwistInputCorrectionMatrixRow2_get", (PyCFunction)_wrap_ImageProcessing_colorTwistInputCorrectionMatrixRow2_get, METH_O, NULL},
	 { (char *)"ImageProcessing_colorTwistEnable_get", (PyCFunction)_wrap_ImageProcessing_colorTwistEnable_get, METH_O, NULL},
	 { (char *)"ImageProcessing_colorTwistRow0_get", (PyCFunction)_wrap_ImageProcessing_colorTwistRow0_get, METH_O, NULL},
	 { (char *)"ImageProcessing_colorTwistRow1_get", (PyCFunction)_wrap_ImageProcessing_colorTwistRow1_get, METH_O, NULL},
	 { (char *)"ImageProcessing_colorTwistRow2_get", (PyCFunction)_wrap_ImageProcessing_colorTwistRow2_get, METH_O, NULL},
	 { (char *)"ImageProcessing_colorTwistOutputCorrectionMatrixEnable_get", (PyCFunction)_wrap_ImageProcessing_colorTwistOutputCorrectionMatrixEnable_get, METH_O, NULL},
	 { (char *)"ImageProcessing_colorTwistOutputCorrectionMatrixMode_get", (PyCFunction)_wrap_ImageProcessing_colorTwistOutputCorrectionMatrixMode_get, METH_O, NULL},
	 { (char *)"ImageProcessing_colorTwistOutputCorrectionMatrixRow0_get", (PyCFunction)_wrap_ImageProcessing_colorTwistOutputCorrectionMatrixRow0_get, METH_O, NULL},
	 { (char *)"ImageProcessing_colorTwistOutputCorrectionMatrixRow1_get", (PyCFunction)_wrap_ImageProcessing_colorTwistOutputCorrectionMatrixRow1_get, METH_O, NULL},
	 { (char *)"ImageProcessing_colorTwistOutputCorrectionMatrixRow2_get", (PyCFunction)_wrap_ImageProcessing_colorTwistOutputCorrectionMatrixRow2_get, METH_O, NULL},
	 { (char *)"ImageProcessing_colorTwistResultingMatrixRow0_get", (PyCFunction)_wrap_ImageProcessing_colorTwistResultingMatrixRow0_get, METH_O, NULL},
	 { (char *)"ImageProcessing_colorTwistResultingMatrixRow1_get", (PyCFunction)_wrap_ImageProcessing_colorTwistResultingMatrixRow1_get, METH_O, NULL},
	 { (char *)"ImageProcessing_colorTwistResultingMatrixRow2_get", (PyCFunction)_wrap_ImageProcessing_colorTwistResultingMatrixRow2_get, METH_O, NULL},
	 { (char *)"ImageProcessing_formatReinterpreterEnable_get", (PyCFunction)_wrap_ImageProcessing_formatReinterpreterEnable_get, METH_O, NULL},
	 { (char *)"ImageProcessing_formatReinterpreterMode_get", (PyCFunction)_wrap_ImageProcessing_formatReinterpreterMode_get, METH_O, NULL},
	 { (char *)"ImageProcessing_rotationEnable_get", (PyCFunction)_wrap_ImageProcessing_rotationEnable_get, METH_O, NULL},
	 { (char *)"ImageProcessing_rotationAngle_get", (PyCFunction)_wrap_ImageProcessing_rotationAngle_get, METH_O, NULL},
	 { (char *)"ImageProcessing_setSaturation", _wrap_ImageProcessing_setSaturation, METH_VARARGS, NULL},
	 { (char *)"ImageProcessing_getGainOffsetKneeParameter", _wrap_ImageProcessing_getGainOffsetKneeParameter, METH_VARARGS, NULL},
	 { (char *)"ImageProcessing_getGainOffsetKneeParameterCount", (PyCFunction)_wrap_ImageProcessing_getGainOffsetKneeParameterCount, METH_O, NULL},
	 { (char *)"ImageProcessing_getMirrorParameter", _wrap_ImageProcessing_getMirrorParameter, METH_VARARGS, NULL},
	 { (char *)"ImageProcessing_getMirrorParameterCount", (PyCFunction)_wrap_ImageProcessing_getMirrorParameterCount, METH_O, NULL},
	 { (char *)"ImageProcessing_getLUTParameter", _wrap_ImageProcessing_getLUTParameter, METH_VARARGS, NULL},
	 { (char *)"ImageProcessing_getLUTParameterCount", (PyCFunction)_wrap_ImageProcessing_getLUTParameterCount, METH_O, NULL},
	 { (char *)"ImageProcessing_getWBUserSetting", _wrap_ImageProcessing_getWBUserSetting, METH_VARARGS, NULL},
	 { (char *)"ImageProcessing_getWBUserSettingsCount", (PyCFunction)_wrap_ImageProcessing_getWBUserSettingsCount, METH_O, NULL},
	 { (char *)"ImageProcessing_swigregister", ImageProcessing_swigregister, METH_VARARGS, NULL},
	 { (char *)"ImageProcessing_swiginit", ImageProcessing_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_Statistics", (PyCFunction)_wrap_new_Statistics, METH_O, NULL},
	 { (char *)"Statistics_reset", (PyCFunction)_wrap_Statistics_reset, METH_O, NULL},
	 { (char *)"Statistics_captureTime_s_get", (PyCFunction)_wrap_Statistics_captureTime_s_get, METH_O, NULL},
	 { (char *)"Statistics_bandwidthConsumed_get", (PyCFunction)_wrap_Statistics_bandwidthConsumed_get, METH_O, NULL},
	 { (char *)"Statistics_errorCount_get", (PyCFunction)_wrap_Statistics_errorCount_get, METH_O, NULL},
	 { (char *)"Statistics_abortedRequestsCount_get", (PyCFunction)_wrap_Statistics_abortedRequestsCount_get, METH_O, NULL},
	 { (char *)"Statistics_timedOutRequestsCount_get", (PyCFunction)_wrap_Statistics_timedOutRequestsCount_get, METH_O, NULL},
	 { (char *)"Statistics_framesPerSecond_get", (PyCFunction)_wrap_Statistics_framesPerSecond_get, METH_O, NULL},
	 { (char *)"Statistics_frameCount_get", (PyCFunction)_wrap_Statistics_frameCount_get, METH_O, NULL},
	 { (char *)"Statistics_imageProcTime_s_get", (PyCFunction)_wrap_Statistics_imageProcTime_s_get, METH_O, NULL},
	 { (char *)"Statistics_formatConvertTime_s_get", (PyCFunction)_wrap_Statistics_formatConvertTime_s_get, METH_O, NULL},
	 { (char *)"Statistics_queueTime_s_get", (PyCFunction)_wrap_Statistics_queueTime_s_get, METH_O, NULL},
	 { (char *)"Statistics_lostImagesCount_get", (PyCFunction)_wrap_Statistics_lostImagesCount_get, METH_O, NULL},
	 { (char *)"Statistics_framesIncompleteCount_get", (PyCFunction)_wrap_Statistics_framesIncompleteCount_get, METH_O, NULL},
	 { (char *)"Statistics_missingDataAverage_pc_get", (PyCFunction)_wrap_Statistics_missingDataAverage_pc_get, METH_O, NULL},
	 { (char *)"Statistics_retransmitCount_get", (PyCFunction)_wrap_Statistics_retransmitCount_get, METH_O, NULL},
	 { (char *)"delete_Statistics", (PyCFunction)_wrap_delete_Statistics, METH_O, NULL},
	 { (char *)"Statistics_swigregister", Statistics_swigregister, METH_VARARGS, NULL},
	 { (char *)"Statistics_swiginit", Statistics_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_FullSettingsBase", _wrap_new_FullSettingsBase, METH_VARARGS, NULL},
	 { (char *)"delete_FullSettingsBase", (PyCFunction)_wrap_delete_FullSettingsBase, METH_O, NULL},
	 { (char *)"FullSettingsBase_imageProcessing_get", (PyCFunction)_wrap_FullSettingsBase_imageProcessing_get, METH_O, NULL},
	 { (char *)"FullSettingsBase_imageDestination_get", (PyCFunction)_wrap_FullSettingsBase_imageDestination_get, METH_O, NULL},
	 { (char *)"FullSettingsBase_basedOn_get", (PyCFunction)_wrap_FullSettingsBase_basedOn_get, METH_O, NULL},
	 { (char *)"FullSettingsBase_swigregister", FullSettingsBase_swigregister, METH_VARARGS, NULL},
	 { (char *)"FullSettingsBase_swiginit", FullSettingsBase_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_SystemSettings", (PyCFunction)_wrap_new_SystemSettings, METH_O, NULL},
	 { (char *)"SystemSettings_requestCount_get", (PyCFunction)_wrap_SystemSettings_requestCount_get, METH_O, NULL},
	 { (char *)"SystemSettings_workerPriority_get", (PyCFunction)_wrap_SystemSettings_workerPriority_get, METH_O, NULL},
	 { (char *)"SystemSettings_acquisitionMode_get", (PyCFunction)_wrap_SystemSettings_acquisitionMode_get, METH_O, NULL},
	 { (char *)"SystemSettings_acquisitionIdleTimeMax_ms_get", (PyCFunction)_wrap_SystemSettings_acquisitionIdleTimeMax_ms_get, METH_O, NULL},
	 { (char *)"SystemSettings_imageProcessingMode_get", (PyCFunction)_wrap_SystemSettings_imageProcessingMode_get, METH_O, NULL},
	 { (char *)"SystemSettings_imageProcessingOptimization_get", (PyCFunction)_wrap_SystemSettings_imageProcessingOptimization_get, METH_O, NULL},
	 { (char *)"SystemSettings_featurePollingEnable_get", (PyCFunction)_wrap_SystemSettings_featurePollingEnable_get, METH_O, NULL},
	 { (char *)"SystemSettings_featurePollingInterval_ms_get", (PyCFunction)_wrap_SystemSettings_featurePollingInterval_ms_get, METH_O, NULL},
	 { (char *)"SystemSettings_methodPollingInterval_ms_get", (PyCFunction)_wrap_SystemSettings_methodPollingInterval_ms_get, METH_O, NULL},
	 { (char *)"SystemSettings_methodPollingMaxRetryCount_get", (PyCFunction)_wrap_SystemSettings_methodPollingMaxRetryCount_get, METH_O, NULL},
	 { (char *)"delete_SystemSettings", (PyCFunction)_wrap_delete_SystemSettings, METH_O, NULL},
	 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
	 { (char *)"SystemSettings_swiginit", SystemSettings_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIAcquisitionField", _wrap_new_PropertyIAcquisitionField, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionField_getTranslationDict", _wrap_PropertyIAcquisitionField_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionField_getTranslationDictString", _wrap_PropertyIAcquisitionField_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionField_getTranslationDictValue", _wrap_PropertyIAcquisitionField_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionField_getTranslationDictStrings", _wrap_PropertyIAcquisitionField_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionField_getTranslationDictValues", _wrap_PropertyIAcquisitionField_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionField_getMaxValue", (PyCFunction)_wrap_PropertyIAcquisitionField_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIAcquisitionField_getMinValue", (PyCFunction)_wrap_PropertyIAcquisitionField_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIAcquisitionField_getStepWidth", (PyCFunction)_wrap_PropertyIAcquisitionField_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIAcquisitionField_read", _wrap_PropertyIAcquisitionField_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionField_write", _wrap_PropertyIAcquisitionField_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIAcquisitionField", (PyCFunction)_wrap_delete_PropertyIAcquisitionField, METH_O, NULL},
	 { (char *)"PropertyIAcquisitionField_swigregister", PropertyIAcquisitionField_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIAcquisitionField_swiginit", PropertyIAcquisitionField_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIAutoControlSpeed", _wrap_new_PropertyIAutoControlSpeed, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoControlSpeed_getTranslationDict", _wrap_PropertyIAutoControlSpeed_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoControlSpeed_getTranslationDictString", _wrap_PropertyIAutoControlSpeed_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoControlSpeed_getTranslationDictValue", _wrap_PropertyIAutoControlSpeed_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoControlSpeed_getTranslationDictStrings", _wrap_PropertyIAutoControlSpeed_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoControlSpeed_getTranslationDictValues", _wrap_PropertyIAutoControlSpeed_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoControlSpeed_getMaxValue", (PyCFunction)_wrap_PropertyIAutoControlSpeed_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIAutoControlSpeed_getMinValue", (PyCFunction)_wrap_PropertyIAutoControlSpeed_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIAutoControlSpeed_getStepWidth", (PyCFunction)_wrap_PropertyIAutoControlSpeed_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIAutoControlSpeed_read", _wrap_PropertyIAutoControlSpeed_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoControlSpeed_write", _wrap_PropertyIAutoControlSpeed_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIAutoControlSpeed", (PyCFunction)_wrap_delete_PropertyIAutoControlSpeed, METH_O, NULL},
	 { (char *)"PropertyIAutoControlSpeed_swigregister", PropertyIAutoControlSpeed_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoControlSpeed_swiginit", PropertyIAutoControlSpeed_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIAutoControlMode", _wrap_new_PropertyIAutoControlMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoControlMode_getTranslationDict", _wrap_PropertyIAutoControlMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoControlMode_getTranslationDictString", _wrap_PropertyIAutoControlMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoControlMode_getTranslationDictValue", _wrap_PropertyIAutoControlMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoControlMode_getTranslationDictStrings", _wrap_PropertyIAutoControlMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoControlMode_getTranslationDictValues", _wrap_PropertyIAutoControlMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoControlMode_getMaxValue", (PyCFunction)_wrap_PropertyIAutoControlMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIAutoControlMode_getMinValue", (PyCFunction)_wrap_PropertyIAutoControlMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIAutoControlMode_getStepWidth", (PyCFunction)_wrap_PropertyIAutoControlMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIAutoControlMode_read", _wrap_PropertyIAutoControlMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoControlMode_write", _wrap_PropertyIAutoControlMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIAutoControlMode", (PyCFunction)_wrap_delete_PropertyIAutoControlMode, METH_O, NULL},
	 { (char *)"PropertyIAutoControlMode_swigregister", PropertyIAutoControlMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoControlMode_swiginit", PropertyIAutoControlMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIAutoExposureControl", _wrap_new_PropertyIAutoExposureControl, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoExposureControl_getTranslationDict", _wrap_PropertyIAutoExposureControl_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoExposureControl_getTranslationDictString", _wrap_PropertyIAutoExposureControl_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoExposureControl_getTranslationDictValue", _wrap_PropertyIAutoExposureControl_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoExposureControl_getTranslationDictStrings", _wrap_PropertyIAutoExposureControl_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoExposureControl_getTranslationDictValues", _wrap_PropertyIAutoExposureControl_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoExposureControl_getMaxValue", (PyCFunction)_wrap_PropertyIAutoExposureControl_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIAutoExposureControl_getMinValue", (PyCFunction)_wrap_PropertyIAutoExposureControl_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIAutoExposureControl_getStepWidth", (PyCFunction)_wrap_PropertyIAutoExposureControl_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIAutoExposureControl_read", _wrap_PropertyIAutoExposureControl_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoExposureControl_write", _wrap_PropertyIAutoExposureControl_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIAutoExposureControl", (PyCFunction)_wrap_delete_PropertyIAutoExposureControl, METH_O, NULL},
	 { (char *)"PropertyIAutoExposureControl_swigregister", PropertyIAutoExposureControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoExposureControl_swiginit", PropertyIAutoExposureControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIAutoGainControl", _wrap_new_PropertyIAutoGainControl, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoGainControl_getTranslationDict", _wrap_PropertyIAutoGainControl_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoGainControl_getTranslationDictString", _wrap_PropertyIAutoGainControl_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoGainControl_getTranslationDictValue", _wrap_PropertyIAutoGainControl_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoGainControl_getTranslationDictStrings", _wrap_PropertyIAutoGainControl_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoGainControl_getTranslationDictValues", _wrap_PropertyIAutoGainControl_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoGainControl_getMaxValue", (PyCFunction)_wrap_PropertyIAutoGainControl_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIAutoGainControl_getMinValue", (PyCFunction)_wrap_PropertyIAutoGainControl_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIAutoGainControl_getStepWidth", (PyCFunction)_wrap_PropertyIAutoGainControl_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIAutoGainControl_read", _wrap_PropertyIAutoGainControl_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoGainControl_write", _wrap_PropertyIAutoGainControl_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIAutoGainControl", (PyCFunction)_wrap_delete_PropertyIAutoGainControl, METH_O, NULL},
	 { (char *)"PropertyIAutoGainControl_swigregister", PropertyIAutoGainControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoGainControl_swiginit", PropertyIAutoGainControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIAutoOffsetCalibration", _wrap_new_PropertyIAutoOffsetCalibration, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoOffsetCalibration_getTranslationDict", _wrap_PropertyIAutoOffsetCalibration_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoOffsetCalibration_getTranslationDictString", _wrap_PropertyIAutoOffsetCalibration_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoOffsetCalibration_getTranslationDictValue", _wrap_PropertyIAutoOffsetCalibration_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoOffsetCalibration_getTranslationDictStrings", _wrap_PropertyIAutoOffsetCalibration_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoOffsetCalibration_getTranslationDictValues", _wrap_PropertyIAutoOffsetCalibration_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoOffsetCalibration_getMaxValue", (PyCFunction)_wrap_PropertyIAutoOffsetCalibration_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIAutoOffsetCalibration_getMinValue", (PyCFunction)_wrap_PropertyIAutoOffsetCalibration_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIAutoOffsetCalibration_getStepWidth", (PyCFunction)_wrap_PropertyIAutoOffsetCalibration_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIAutoOffsetCalibration_read", _wrap_PropertyIAutoOffsetCalibration_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoOffsetCalibration_write", _wrap_PropertyIAutoOffsetCalibration_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIAutoOffsetCalibration", (PyCFunction)_wrap_delete_PropertyIAutoOffsetCalibration, METH_O, NULL},
	 { (char *)"PropertyIAutoOffsetCalibration_swigregister", PropertyIAutoOffsetCalibration_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIAutoOffsetCalibration_swiginit", PropertyIAutoOffsetCalibration_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIBlueFOXDigitalInputThreshold", _wrap_new_PropertyIBlueFOXDigitalInputThreshold, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXDigitalInputThreshold_getTranslationDict", _wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXDigitalInputThreshold_getTranslationDictString", _wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValue", _wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXDigitalInputThreshold_getTranslationDictStrings", _wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValues", _wrap_PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXDigitalInputThreshold_getMaxValue", (PyCFunction)_wrap_PropertyIBlueFOXDigitalInputThreshold_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXDigitalInputThreshold_getMinValue", (PyCFunction)_wrap_PropertyIBlueFOXDigitalInputThreshold_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXDigitalInputThreshold_getStepWidth", (PyCFunction)_wrap_PropertyIBlueFOXDigitalInputThreshold_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXDigitalInputThreshold_read", _wrap_PropertyIBlueFOXDigitalInputThreshold_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXDigitalInputThreshold_write", _wrap_PropertyIBlueFOXDigitalInputThreshold_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIBlueFOXDigitalInputThreshold", (PyCFunction)_wrap_delete_PropertyIBlueFOXDigitalInputThreshold, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXDigitalInputThreshold_swigregister", PropertyIBlueFOXDigitalInputThreshold_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXDigitalInputThreshold_swiginit", PropertyIBlueFOXDigitalInputThreshold_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIBlueFOXFooterMode", _wrap_new_PropertyIBlueFOXFooterMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXFooterMode_getTranslationDict", _wrap_PropertyIBlueFOXFooterMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXFooterMode_getTranslationDictString", _wrap_PropertyIBlueFOXFooterMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXFooterMode_getTranslationDictValue", _wrap_PropertyIBlueFOXFooterMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXFooterMode_getTranslationDictStrings", _wrap_PropertyIBlueFOXFooterMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXFooterMode_getTranslationDictValues", _wrap_PropertyIBlueFOXFooterMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXFooterMode_getMaxValue", (PyCFunction)_wrap_PropertyIBlueFOXFooterMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXFooterMode_getMinValue", (PyCFunction)_wrap_PropertyIBlueFOXFooterMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXFooterMode_getStepWidth", (PyCFunction)_wrap_PropertyIBlueFOXFooterMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXFooterMode_read", _wrap_PropertyIBlueFOXFooterMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXFooterMode_write", _wrap_PropertyIBlueFOXFooterMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIBlueFOXFooterMode", (PyCFunction)_wrap_delete_PropertyIBlueFOXFooterMode, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXFooterMode_swigregister", PropertyIBlueFOXFooterMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXFooterMode_swiginit", PropertyIBlueFOXFooterMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIBlueFOXInfoSensorCapabilities", _wrap_new_PropertyIBlueFOXInfoSensorCapabilities, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXInfoSensorCapabilities_getTranslationDict", _wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictString", _wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValue", _wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictStrings", _wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValues", _wrap_PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXInfoSensorCapabilities_getMaxValue", (PyCFunction)_wrap_PropertyIBlueFOXInfoSensorCapabilities_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXInfoSensorCapabilities_getMinValue", (PyCFunction)_wrap_PropertyIBlueFOXInfoSensorCapabilities_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXInfoSensorCapabilities_getStepWidth", (PyCFunction)_wrap_PropertyIBlueFOXInfoSensorCapabilities_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXInfoSensorCapabilities_read", _wrap_PropertyIBlueFOXInfoSensorCapabilities_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXInfoSensorCapabilities_write", _wrap_PropertyIBlueFOXInfoSensorCapabilities_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIBlueFOXInfoSensorCapabilities", (PyCFunction)_wrap_delete_PropertyIBlueFOXInfoSensorCapabilities, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXInfoSensorCapabilities_swigregister", PropertyIBlueFOXInfoSensorCapabilities_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXInfoSensorCapabilities_swiginit", PropertyIBlueFOXInfoSensorCapabilities_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIBlueFOXOffsetAutoBlackSpeed", _wrap_new_PropertyIBlueFOXOffsetAutoBlackSpeed, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDict", _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictString", _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValue", _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictStrings", _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValues", _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXOffsetAutoBlackSpeed_getMaxValue", (PyCFunction)_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXOffsetAutoBlackSpeed_getMinValue", (PyCFunction)_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXOffsetAutoBlackSpeed_getStepWidth", (PyCFunction)_wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXOffsetAutoBlackSpeed_read", _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXOffsetAutoBlackSpeed_write", _wrap_PropertyIBlueFOXOffsetAutoBlackSpeed_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIBlueFOXOffsetAutoBlackSpeed", (PyCFunction)_wrap_delete_PropertyIBlueFOXOffsetAutoBlackSpeed, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXOffsetAutoBlackSpeed_swigregister", PropertyIBlueFOXOffsetAutoBlackSpeed_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXOffsetAutoBlackSpeed_swiginit", PropertyIBlueFOXOffsetAutoBlackSpeed_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIBlueFOXSensorTiming", _wrap_new_PropertyIBlueFOXSensorTiming, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXSensorTiming_getTranslationDict", _wrap_PropertyIBlueFOXSensorTiming_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXSensorTiming_getTranslationDictString", _wrap_PropertyIBlueFOXSensorTiming_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXSensorTiming_getTranslationDictValue", _wrap_PropertyIBlueFOXSensorTiming_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXSensorTiming_getTranslationDictStrings", _wrap_PropertyIBlueFOXSensorTiming_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXSensorTiming_getTranslationDictValues", _wrap_PropertyIBlueFOXSensorTiming_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXSensorTiming_getMaxValue", (PyCFunction)_wrap_PropertyIBlueFOXSensorTiming_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXSensorTiming_getMinValue", (PyCFunction)_wrap_PropertyIBlueFOXSensorTiming_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXSensorTiming_getStepWidth", (PyCFunction)_wrap_PropertyIBlueFOXSensorTiming_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXSensorTiming_read", _wrap_PropertyIBlueFOXSensorTiming_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXSensorTiming_write", _wrap_PropertyIBlueFOXSensorTiming_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIBlueFOXSensorTiming", (PyCFunction)_wrap_delete_PropertyIBlueFOXSensorTiming, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXSensorTiming_swigregister", PropertyIBlueFOXSensorTiming_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXSensorTiming_swiginit", PropertyIBlueFOXSensorTiming_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIBlueFOXTransferSize", _wrap_new_PropertyIBlueFOXTransferSize, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXTransferSize_getTranslationDict", _wrap_PropertyIBlueFOXTransferSize_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXTransferSize_getTranslationDictString", _wrap_PropertyIBlueFOXTransferSize_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXTransferSize_getTranslationDictValue", _wrap_PropertyIBlueFOXTransferSize_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXTransferSize_getTranslationDictStrings", _wrap_PropertyIBlueFOXTransferSize_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXTransferSize_getTranslationDictValues", _wrap_PropertyIBlueFOXTransferSize_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXTransferSize_getMaxValue", (PyCFunction)_wrap_PropertyIBlueFOXTransferSize_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXTransferSize_getMinValue", (PyCFunction)_wrap_PropertyIBlueFOXTransferSize_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXTransferSize_getStepWidth", (PyCFunction)_wrap_PropertyIBlueFOXTransferSize_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXTransferSize_read", _wrap_PropertyIBlueFOXTransferSize_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXTransferSize_write", _wrap_PropertyIBlueFOXTransferSize_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIBlueFOXTransferSize", (PyCFunction)_wrap_delete_PropertyIBlueFOXTransferSize, METH_O, NULL},
	 { (char *)"PropertyIBlueFOXTransferSize_swigregister", PropertyIBlueFOXTransferSize_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIBlueFOXTransferSize_swiginit", PropertyIBlueFOXTransferSize_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyICameraAoiMode", _wrap_new_PropertyICameraAoiMode, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraAoiMode_getTranslationDict", _wrap_PropertyICameraAoiMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraAoiMode_getTranslationDictString", _wrap_PropertyICameraAoiMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraAoiMode_getTranslationDictValue", _wrap_PropertyICameraAoiMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraAoiMode_getTranslationDictStrings", _wrap_PropertyICameraAoiMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraAoiMode_getTranslationDictValues", _wrap_PropertyICameraAoiMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraAoiMode_getMaxValue", (PyCFunction)_wrap_PropertyICameraAoiMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyICameraAoiMode_getMinValue", (PyCFunction)_wrap_PropertyICameraAoiMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyICameraAoiMode_getStepWidth", (PyCFunction)_wrap_PropertyICameraAoiMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyICameraAoiMode_read", _wrap_PropertyICameraAoiMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraAoiMode_write", _wrap_PropertyICameraAoiMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyICameraAoiMode", (PyCFunction)_wrap_delete_PropertyICameraAoiMode, METH_O, NULL},
	 { (char *)"PropertyICameraAoiMode_swigregister", PropertyICameraAoiMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraAoiMode_swiginit", PropertyICameraAoiMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyICameraBinningMode", _wrap_new_PropertyICameraBinningMode, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraBinningMode_getTranslationDict", _wrap_PropertyICameraBinningMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraBinningMode_getTranslationDictString", _wrap_PropertyICameraBinningMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraBinningMode_getTranslationDictValue", _wrap_PropertyICameraBinningMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraBinningMode_getTranslationDictStrings", _wrap_PropertyICameraBinningMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraBinningMode_getTranslationDictValues", _wrap_PropertyICameraBinningMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraBinningMode_getMaxValue", (PyCFunction)_wrap_PropertyICameraBinningMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyICameraBinningMode_getMinValue", (PyCFunction)_wrap_PropertyICameraBinningMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyICameraBinningMode_getStepWidth", (PyCFunction)_wrap_PropertyICameraBinningMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyICameraBinningMode_read", _wrap_PropertyICameraBinningMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraBinningMode_write", _wrap_PropertyICameraBinningMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyICameraBinningMode", (PyCFunction)_wrap_delete_PropertyICameraBinningMode, METH_O, NULL},
	 { (char *)"PropertyICameraBinningMode_swigregister", PropertyICameraBinningMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraBinningMode_swiginit", PropertyICameraBinningMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyICameraDataFormat", _wrap_new_PropertyICameraDataFormat, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraDataFormat_getTranslationDict", _wrap_PropertyICameraDataFormat_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraDataFormat_getTranslationDictString", _wrap_PropertyICameraDataFormat_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraDataFormat_getTranslationDictValue", _wrap_PropertyICameraDataFormat_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraDataFormat_getTranslationDictStrings", _wrap_PropertyICameraDataFormat_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraDataFormat_getTranslationDictValues", _wrap_PropertyICameraDataFormat_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraDataFormat_getMaxValue", (PyCFunction)_wrap_PropertyICameraDataFormat_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyICameraDataFormat_getMinValue", (PyCFunction)_wrap_PropertyICameraDataFormat_getMinValue, METH_O, NULL},
	 { (char *)"PropertyICameraDataFormat_getStepWidth", (PyCFunction)_wrap_PropertyICameraDataFormat_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyICameraDataFormat_read", _wrap_PropertyICameraDataFormat_read, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraDataFormat_write", _wrap_PropertyICameraDataFormat_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyICameraDataFormat", (PyCFunction)_wrap_delete_PropertyICameraDataFormat, METH_O, NULL},
	 { (char *)"PropertyICameraDataFormat_swigregister", PropertyICameraDataFormat_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraDataFormat_swiginit", PropertyICameraDataFormat_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyICameraExposeMode", _wrap_new_PropertyICameraExposeMode, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExposeMode_getTranslationDict", _wrap_PropertyICameraExposeMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExposeMode_getTranslationDictString", _wrap_PropertyICameraExposeMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExposeMode_getTranslationDictValue", _wrap_PropertyICameraExposeMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExposeMode_getTranslationDictStrings", _wrap_PropertyICameraExposeMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExposeMode_getTranslationDictValues", _wrap_PropertyICameraExposeMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExposeMode_getMaxValue", (PyCFunction)_wrap_PropertyICameraExposeMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyICameraExposeMode_getMinValue", (PyCFunction)_wrap_PropertyICameraExposeMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyICameraExposeMode_getStepWidth", (PyCFunction)_wrap_PropertyICameraExposeMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyICameraExposeMode_read", _wrap_PropertyICameraExposeMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExposeMode_write", _wrap_PropertyICameraExposeMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyICameraExposeMode", (PyCFunction)_wrap_delete_PropertyICameraExposeMode, METH_O, NULL},
	 { (char *)"PropertyICameraExposeMode_swigregister", PropertyICameraExposeMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExposeMode_swiginit", PropertyICameraExposeMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyICameraExternalSyncEdge", _wrap_new_PropertyICameraExternalSyncEdge, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExternalSyncEdge_getTranslationDict", _wrap_PropertyICameraExternalSyncEdge_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExternalSyncEdge_getTranslationDictString", _wrap_PropertyICameraExternalSyncEdge_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExternalSyncEdge_getTranslationDictValue", _wrap_PropertyICameraExternalSyncEdge_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExternalSyncEdge_getTranslationDictStrings", _wrap_PropertyICameraExternalSyncEdge_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExternalSyncEdge_getTranslationDictValues", _wrap_PropertyICameraExternalSyncEdge_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExternalSyncEdge_getMaxValue", (PyCFunction)_wrap_PropertyICameraExternalSyncEdge_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyICameraExternalSyncEdge_getMinValue", (PyCFunction)_wrap_PropertyICameraExternalSyncEdge_getMinValue, METH_O, NULL},
	 { (char *)"PropertyICameraExternalSyncEdge_getStepWidth", (PyCFunction)_wrap_PropertyICameraExternalSyncEdge_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyICameraExternalSyncEdge_read", _wrap_PropertyICameraExternalSyncEdge_read, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExternalSyncEdge_write", _wrap_PropertyICameraExternalSyncEdge_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyICameraExternalSyncEdge", (PyCFunction)_wrap_delete_PropertyICameraExternalSyncEdge, METH_O, NULL},
	 { (char *)"PropertyICameraExternalSyncEdge_swigregister", PropertyICameraExternalSyncEdge_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExternalSyncEdge_swiginit", PropertyICameraExternalSyncEdge_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyICameraExternalSyncOutput", _wrap_new_PropertyICameraExternalSyncOutput, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExternalSyncOutput_getTranslationDict", _wrap_PropertyICameraExternalSyncOutput_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExternalSyncOutput_getTranslationDictString", _wrap_PropertyICameraExternalSyncOutput_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExternalSyncOutput_getTranslationDictValue", _wrap_PropertyICameraExternalSyncOutput_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExternalSyncOutput_getTranslationDictStrings", _wrap_PropertyICameraExternalSyncOutput_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExternalSyncOutput_getTranslationDictValues", _wrap_PropertyICameraExternalSyncOutput_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExternalSyncOutput_getMaxValue", (PyCFunction)_wrap_PropertyICameraExternalSyncOutput_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyICameraExternalSyncOutput_getMinValue", (PyCFunction)_wrap_PropertyICameraExternalSyncOutput_getMinValue, METH_O, NULL},
	 { (char *)"PropertyICameraExternalSyncOutput_getStepWidth", (PyCFunction)_wrap_PropertyICameraExternalSyncOutput_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyICameraExternalSyncOutput_read", _wrap_PropertyICameraExternalSyncOutput_read, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExternalSyncOutput_write", _wrap_PropertyICameraExternalSyncOutput_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyICameraExternalSyncOutput", (PyCFunction)_wrap_delete_PropertyICameraExternalSyncOutput, METH_O, NULL},
	 { (char *)"PropertyICameraExternalSyncOutput_swigregister", PropertyICameraExternalSyncOutput_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraExternalSyncOutput_swiginit", PropertyICameraExternalSyncOutput_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyICameraFlashMode", _wrap_new_PropertyICameraFlashMode, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraFlashMode_getTranslationDict", _wrap_PropertyICameraFlashMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraFlashMode_getTranslationDictString", _wrap_PropertyICameraFlashMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraFlashMode_getTranslationDictValue", _wrap_PropertyICameraFlashMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraFlashMode_getTranslationDictStrings", _wrap_PropertyICameraFlashMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraFlashMode_getTranslationDictValues", _wrap_PropertyICameraFlashMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraFlashMode_getMaxValue", (PyCFunction)_wrap_PropertyICameraFlashMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyICameraFlashMode_getMinValue", (PyCFunction)_wrap_PropertyICameraFlashMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyICameraFlashMode_getStepWidth", (PyCFunction)_wrap_PropertyICameraFlashMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyICameraFlashMode_read", _wrap_PropertyICameraFlashMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraFlashMode_write", _wrap_PropertyICameraFlashMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyICameraFlashMode", (PyCFunction)_wrap_delete_PropertyICameraFlashMode, METH_O, NULL},
	 { (char *)"PropertyICameraFlashMode_swigregister", PropertyICameraFlashMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraFlashMode_swiginit", PropertyICameraFlashMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyICameraFlashType", _wrap_new_PropertyICameraFlashType, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraFlashType_getTranslationDict", _wrap_PropertyICameraFlashType_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraFlashType_getTranslationDictString", _wrap_PropertyICameraFlashType_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraFlashType_getTranslationDictValue", _wrap_PropertyICameraFlashType_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraFlashType_getTranslationDictStrings", _wrap_PropertyICameraFlashType_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraFlashType_getTranslationDictValues", _wrap_PropertyICameraFlashType_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraFlashType_getMaxValue", (PyCFunction)_wrap_PropertyICameraFlashType_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyICameraFlashType_getMinValue", (PyCFunction)_wrap_PropertyICameraFlashType_getMinValue, METH_O, NULL},
	 { (char *)"PropertyICameraFlashType_getStepWidth", (PyCFunction)_wrap_PropertyICameraFlashType_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyICameraFlashType_read", _wrap_PropertyICameraFlashType_read, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraFlashType_write", _wrap_PropertyICameraFlashType_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyICameraFlashType", (PyCFunction)_wrap_delete_PropertyICameraFlashType, METH_O, NULL},
	 { (char *)"PropertyICameraFlashType_swigregister", PropertyICameraFlashType_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraFlashType_swiginit", PropertyICameraFlashType_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyICameraHDRMode", _wrap_new_PropertyICameraHDRMode, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraHDRMode_getTranslationDict", _wrap_PropertyICameraHDRMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraHDRMode_getTranslationDictString", _wrap_PropertyICameraHDRMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraHDRMode_getTranslationDictValue", _wrap_PropertyICameraHDRMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraHDRMode_getTranslationDictStrings", _wrap_PropertyICameraHDRMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraHDRMode_getTranslationDictValues", _wrap_PropertyICameraHDRMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraHDRMode_getMaxValue", (PyCFunction)_wrap_PropertyICameraHDRMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyICameraHDRMode_getMinValue", (PyCFunction)_wrap_PropertyICameraHDRMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyICameraHDRMode_getStepWidth", (PyCFunction)_wrap_PropertyICameraHDRMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyICameraHDRMode_read", _wrap_PropertyICameraHDRMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraHDRMode_write", _wrap_PropertyICameraHDRMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyICameraHDRMode", (PyCFunction)_wrap_delete_PropertyICameraHDRMode, METH_O, NULL},
	 { (char *)"PropertyICameraHDRMode_swigregister", PropertyICameraHDRMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraHDRMode_swiginit", PropertyICameraHDRMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyICameraInterlacedType", _wrap_new_PropertyICameraInterlacedType, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraInterlacedType_getTranslationDict", _wrap_PropertyICameraInterlacedType_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraInterlacedType_getTranslationDictString", _wrap_PropertyICameraInterlacedType_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraInterlacedType_getTranslationDictValue", _wrap_PropertyICameraInterlacedType_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraInterlacedType_getTranslationDictStrings", _wrap_PropertyICameraInterlacedType_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraInterlacedType_getTranslationDictValues", _wrap_PropertyICameraInterlacedType_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraInterlacedType_getMaxValue", (PyCFunction)_wrap_PropertyICameraInterlacedType_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyICameraInterlacedType_getMinValue", (PyCFunction)_wrap_PropertyICameraInterlacedType_getMinValue, METH_O, NULL},
	 { (char *)"PropertyICameraInterlacedType_getStepWidth", (PyCFunction)_wrap_PropertyICameraInterlacedType_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyICameraInterlacedType_read", _wrap_PropertyICameraInterlacedType_read, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraInterlacedType_write", _wrap_PropertyICameraInterlacedType_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyICameraInterlacedType", (PyCFunction)_wrap_delete_PropertyICameraInterlacedType, METH_O, NULL},
	 { (char *)"PropertyICameraInterlacedType_swigregister", PropertyICameraInterlacedType_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraInterlacedType_swiginit", PropertyICameraInterlacedType_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyICameraLinkDataValidMode", _wrap_new_PropertyICameraLinkDataValidMode, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraLinkDataValidMode_getTranslationDict", _wrap_PropertyICameraLinkDataValidMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraLinkDataValidMode_getTranslationDictString", _wrap_PropertyICameraLinkDataValidMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraLinkDataValidMode_getTranslationDictValue", _wrap_PropertyICameraLinkDataValidMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraLinkDataValidMode_getTranslationDictStrings", _wrap_PropertyICameraLinkDataValidMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraLinkDataValidMode_getTranslationDictValues", _wrap_PropertyICameraLinkDataValidMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraLinkDataValidMode_getMaxValue", (PyCFunction)_wrap_PropertyICameraLinkDataValidMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyICameraLinkDataValidMode_getMinValue", (PyCFunction)_wrap_PropertyICameraLinkDataValidMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyICameraLinkDataValidMode_getStepWidth", (PyCFunction)_wrap_PropertyICameraLinkDataValidMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyICameraLinkDataValidMode_read", _wrap_PropertyICameraLinkDataValidMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraLinkDataValidMode_write", _wrap_PropertyICameraLinkDataValidMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyICameraLinkDataValidMode", (PyCFunction)_wrap_delete_PropertyICameraLinkDataValidMode, METH_O, NULL},
	 { (char *)"PropertyICameraLinkDataValidMode_swigregister", PropertyICameraLinkDataValidMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraLinkDataValidMode_swiginit", PropertyICameraLinkDataValidMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyICameraPixelClock", _wrap_new_PropertyICameraPixelClock, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraPixelClock_getTranslationDict", _wrap_PropertyICameraPixelClock_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraPixelClock_getTranslationDictString", _wrap_PropertyICameraPixelClock_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraPixelClock_getTranslationDictValue", _wrap_PropertyICameraPixelClock_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraPixelClock_getTranslationDictStrings", _wrap_PropertyICameraPixelClock_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraPixelClock_getTranslationDictValues", _wrap_PropertyICameraPixelClock_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraPixelClock_getMaxValue", (PyCFunction)_wrap_PropertyICameraPixelClock_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyICameraPixelClock_getMinValue", (PyCFunction)_wrap_PropertyICameraPixelClock_getMinValue, METH_O, NULL},
	 { (char *)"PropertyICameraPixelClock_getStepWidth", (PyCFunction)_wrap_PropertyICameraPixelClock_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyICameraPixelClock_read", _wrap_PropertyICameraPixelClock_read, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraPixelClock_write", _wrap_PropertyICameraPixelClock_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyICameraPixelClock", (PyCFunction)_wrap_delete_PropertyICameraPixelClock, METH_O, NULL},
	 { (char *)"PropertyICameraPixelClock_swigregister", PropertyICameraPixelClock_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraPixelClock_swiginit", PropertyICameraPixelClock_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyICameraScanMode", _wrap_new_PropertyICameraScanMode, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraScanMode_getTranslationDict", _wrap_PropertyICameraScanMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraScanMode_getTranslationDictString", _wrap_PropertyICameraScanMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraScanMode_getTranslationDictValue", _wrap_PropertyICameraScanMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraScanMode_getTranslationDictStrings", _wrap_PropertyICameraScanMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraScanMode_getTranslationDictValues", _wrap_PropertyICameraScanMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraScanMode_getMaxValue", (PyCFunction)_wrap_PropertyICameraScanMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyICameraScanMode_getMinValue", (PyCFunction)_wrap_PropertyICameraScanMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyICameraScanMode_getStepWidth", (PyCFunction)_wrap_PropertyICameraScanMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyICameraScanMode_read", _wrap_PropertyICameraScanMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraScanMode_write", _wrap_PropertyICameraScanMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyICameraScanMode", (PyCFunction)_wrap_delete_PropertyICameraScanMode, METH_O, NULL},
	 { (char *)"PropertyICameraScanMode_swigregister", PropertyICameraScanMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraScanMode_swiginit", PropertyICameraScanMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyICameraShutterMode", _wrap_new_PropertyICameraShutterMode, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraShutterMode_getTranslationDict", _wrap_PropertyICameraShutterMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraShutterMode_getTranslationDictString", _wrap_PropertyICameraShutterMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraShutterMode_getTranslationDictValue", _wrap_PropertyICameraShutterMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraShutterMode_getTranslationDictStrings", _wrap_PropertyICameraShutterMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraShutterMode_getTranslationDictValues", _wrap_PropertyICameraShutterMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraShutterMode_getMaxValue", (PyCFunction)_wrap_PropertyICameraShutterMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyICameraShutterMode_getMinValue", (PyCFunction)_wrap_PropertyICameraShutterMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyICameraShutterMode_getStepWidth", (PyCFunction)_wrap_PropertyICameraShutterMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyICameraShutterMode_read", _wrap_PropertyICameraShutterMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraShutterMode_write", _wrap_PropertyICameraShutterMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyICameraShutterMode", (PyCFunction)_wrap_delete_PropertyICameraShutterMode, METH_O, NULL},
	 { (char *)"PropertyICameraShutterMode_swigregister", PropertyICameraShutterMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraShutterMode_swiginit", PropertyICameraShutterMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyICameraTapsXGeometry", _wrap_new_PropertyICameraTapsXGeometry, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTapsXGeometry_getTranslationDict", _wrap_PropertyICameraTapsXGeometry_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTapsXGeometry_getTranslationDictString", _wrap_PropertyICameraTapsXGeometry_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTapsXGeometry_getTranslationDictValue", _wrap_PropertyICameraTapsXGeometry_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTapsXGeometry_getTranslationDictStrings", _wrap_PropertyICameraTapsXGeometry_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTapsXGeometry_getTranslationDictValues", _wrap_PropertyICameraTapsXGeometry_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTapsXGeometry_getMaxValue", (PyCFunction)_wrap_PropertyICameraTapsXGeometry_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyICameraTapsXGeometry_getMinValue", (PyCFunction)_wrap_PropertyICameraTapsXGeometry_getMinValue, METH_O, NULL},
	 { (char *)"PropertyICameraTapsXGeometry_getStepWidth", (PyCFunction)_wrap_PropertyICameraTapsXGeometry_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyICameraTapsXGeometry_read", _wrap_PropertyICameraTapsXGeometry_read, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTapsXGeometry_write", _wrap_PropertyICameraTapsXGeometry_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyICameraTapsXGeometry", (PyCFunction)_wrap_delete_PropertyICameraTapsXGeometry, METH_O, NULL},
	 { (char *)"PropertyICameraTapsXGeometry_swigregister", PropertyICameraTapsXGeometry_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTapsXGeometry_swiginit", PropertyICameraTapsXGeometry_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyICameraTapsYGeometry", _wrap_new_PropertyICameraTapsYGeometry, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTapsYGeometry_getTranslationDict", _wrap_PropertyICameraTapsYGeometry_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTapsYGeometry_getTranslationDictString", _wrap_PropertyICameraTapsYGeometry_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTapsYGeometry_getTranslationDictValue", _wrap_PropertyICameraTapsYGeometry_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTapsYGeometry_getTranslationDictStrings", _wrap_PropertyICameraTapsYGeometry_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTapsYGeometry_getTranslationDictValues", _wrap_PropertyICameraTapsYGeometry_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTapsYGeometry_getMaxValue", (PyCFunction)_wrap_PropertyICameraTapsYGeometry_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyICameraTapsYGeometry_getMinValue", (PyCFunction)_wrap_PropertyICameraTapsYGeometry_getMinValue, METH_O, NULL},
	 { (char *)"PropertyICameraTapsYGeometry_getStepWidth", (PyCFunction)_wrap_PropertyICameraTapsYGeometry_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyICameraTapsYGeometry_read", _wrap_PropertyICameraTapsYGeometry_read, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTapsYGeometry_write", _wrap_PropertyICameraTapsYGeometry_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyICameraTapsYGeometry", (PyCFunction)_wrap_delete_PropertyICameraTapsYGeometry, METH_O, NULL},
	 { (char *)"PropertyICameraTapsYGeometry_swigregister", PropertyICameraTapsYGeometry_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTapsYGeometry_swiginit", PropertyICameraTapsYGeometry_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyICameraTriggerMode", _wrap_new_PropertyICameraTriggerMode, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTriggerMode_getTranslationDict", _wrap_PropertyICameraTriggerMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTriggerMode_getTranslationDictString", _wrap_PropertyICameraTriggerMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTriggerMode_getTranslationDictValue", _wrap_PropertyICameraTriggerMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTriggerMode_getTranslationDictStrings", _wrap_PropertyICameraTriggerMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTriggerMode_getTranslationDictValues", _wrap_PropertyICameraTriggerMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTriggerMode_getMaxValue", (PyCFunction)_wrap_PropertyICameraTriggerMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyICameraTriggerMode_getMinValue", (PyCFunction)_wrap_PropertyICameraTriggerMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyICameraTriggerMode_getStepWidth", (PyCFunction)_wrap_PropertyICameraTriggerMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyICameraTriggerMode_read", _wrap_PropertyICameraTriggerMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTriggerMode_write", _wrap_PropertyICameraTriggerMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyICameraTriggerMode", (PyCFunction)_wrap_delete_PropertyICameraTriggerMode, METH_O, NULL},
	 { (char *)"PropertyICameraTriggerMode_swigregister", PropertyICameraTriggerMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTriggerMode_swiginit", PropertyICameraTriggerMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyICameraTestMode", _wrap_new_PropertyICameraTestMode, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTestMode_getTranslationDict", _wrap_PropertyICameraTestMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTestMode_getTranslationDictString", _wrap_PropertyICameraTestMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTestMode_getTranslationDictValue", _wrap_PropertyICameraTestMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTestMode_getTranslationDictStrings", _wrap_PropertyICameraTestMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTestMode_getTranslationDictValues", _wrap_PropertyICameraTestMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTestMode_getMaxValue", (PyCFunction)_wrap_PropertyICameraTestMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyICameraTestMode_getMinValue", (PyCFunction)_wrap_PropertyICameraTestMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyICameraTestMode_getStepWidth", (PyCFunction)_wrap_PropertyICameraTestMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyICameraTestMode_read", _wrap_PropertyICameraTestMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTestMode_write", _wrap_PropertyICameraTestMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyICameraTestMode", (PyCFunction)_wrap_delete_PropertyICameraTestMode, METH_O, NULL},
	 { (char *)"PropertyICameraTestMode_swigregister", PropertyICameraTestMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTestMode_swiginit", PropertyICameraTestMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyICameraSerialPortBaudRate", _wrap_new_PropertyICameraSerialPortBaudRate, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraSerialPortBaudRate_getTranslationDict", _wrap_PropertyICameraSerialPortBaudRate_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraSerialPortBaudRate_getTranslationDictString", _wrap_PropertyICameraSerialPortBaudRate_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraSerialPortBaudRate_getTranslationDictValue", _wrap_PropertyICameraSerialPortBaudRate_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraSerialPortBaudRate_getTranslationDictStrings", _wrap_PropertyICameraSerialPortBaudRate_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraSerialPortBaudRate_getTranslationDictValues", _wrap_PropertyICameraSerialPortBaudRate_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraSerialPortBaudRate_getMaxValue", (PyCFunction)_wrap_PropertyICameraSerialPortBaudRate_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyICameraSerialPortBaudRate_getMinValue", (PyCFunction)_wrap_PropertyICameraSerialPortBaudRate_getMinValue, METH_O, NULL},
	 { (char *)"PropertyICameraSerialPortBaudRate_getStepWidth", (PyCFunction)_wrap_PropertyICameraSerialPortBaudRate_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyICameraSerialPortBaudRate_read", _wrap_PropertyICameraSerialPortBaudRate_read, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraSerialPortBaudRate_write", _wrap_PropertyICameraSerialPortBaudRate_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyICameraSerialPortBaudRate", (PyCFunction)_wrap_delete_PropertyICameraSerialPortBaudRate, METH_O, NULL},
	 { (char *)"PropertyICameraSerialPortBaudRate_swigregister", PropertyICameraSerialPortBaudRate_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraSerialPortBaudRate_swiginit", PropertyICameraSerialPortBaudRate_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyICameraTriggerSource", _wrap_new_PropertyICameraTriggerSource, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTriggerSource_getTranslationDict", _wrap_PropertyICameraTriggerSource_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTriggerSource_getTranslationDictString", _wrap_PropertyICameraTriggerSource_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTriggerSource_getTranslationDictValue", _wrap_PropertyICameraTriggerSource_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTriggerSource_getTranslationDictStrings", _wrap_PropertyICameraTriggerSource_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTriggerSource_getTranslationDictValues", _wrap_PropertyICameraTriggerSource_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTriggerSource_getMaxValue", (PyCFunction)_wrap_PropertyICameraTriggerSource_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyICameraTriggerSource_getMinValue", (PyCFunction)_wrap_PropertyICameraTriggerSource_getMinValue, METH_O, NULL},
	 { (char *)"PropertyICameraTriggerSource_getStepWidth", (PyCFunction)_wrap_PropertyICameraTriggerSource_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyICameraTriggerSource_read", _wrap_PropertyICameraTriggerSource_read, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTriggerSource_write", _wrap_PropertyICameraTriggerSource_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyICameraTriggerSource", (PyCFunction)_wrap_delete_PropertyICameraTriggerSource, METH_O, NULL},
	 { (char *)"PropertyICameraTriggerSource_swigregister", PropertyICameraTriggerSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyICameraTriggerSource_swiginit", PropertyICameraTriggerSource_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIClampMode", _wrap_new_PropertyIClampMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIClampMode_getTranslationDict", _wrap_PropertyIClampMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIClampMode_getTranslationDictString", _wrap_PropertyIClampMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIClampMode_getTranslationDictValue", _wrap_PropertyIClampMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIClampMode_getTranslationDictStrings", _wrap_PropertyIClampMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIClampMode_getTranslationDictValues", _wrap_PropertyIClampMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIClampMode_getMaxValue", (PyCFunction)_wrap_PropertyIClampMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIClampMode_getMinValue", (PyCFunction)_wrap_PropertyIClampMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIClampMode_getStepWidth", (PyCFunction)_wrap_PropertyIClampMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIClampMode_read", _wrap_PropertyIClampMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIClampMode_write", _wrap_PropertyIClampMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIClampMode", (PyCFunction)_wrap_delete_PropertyIClampMode, METH_O, NULL},
	 { (char *)"PropertyIClampMode_swigregister", PropertyIClampMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIClampMode_swiginit", PropertyIClampMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDeviceAdvancedOptions", _wrap_new_PropertyIDeviceAdvancedOptions, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceAdvancedOptions_getTranslationDict", _wrap_PropertyIDeviceAdvancedOptions_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceAdvancedOptions_getTranslationDictString", _wrap_PropertyIDeviceAdvancedOptions_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceAdvancedOptions_getTranslationDictValue", _wrap_PropertyIDeviceAdvancedOptions_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceAdvancedOptions_getTranslationDictStrings", _wrap_PropertyIDeviceAdvancedOptions_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceAdvancedOptions_getTranslationDictValues", _wrap_PropertyIDeviceAdvancedOptions_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceAdvancedOptions_getMaxValue", (PyCFunction)_wrap_PropertyIDeviceAdvancedOptions_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceAdvancedOptions_getMinValue", (PyCFunction)_wrap_PropertyIDeviceAdvancedOptions_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceAdvancedOptions_getStepWidth", (PyCFunction)_wrap_PropertyIDeviceAdvancedOptions_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDeviceAdvancedOptions_read", _wrap_PropertyIDeviceAdvancedOptions_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceAdvancedOptions_write", _wrap_PropertyIDeviceAdvancedOptions_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDeviceAdvancedOptions", (PyCFunction)_wrap_delete_PropertyIDeviceAdvancedOptions, METH_O, NULL},
	 { (char *)"PropertyIDeviceAdvancedOptions_swigregister", PropertyIDeviceAdvancedOptions_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceAdvancedOptions_swiginit", PropertyIDeviceAdvancedOptions_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDeviceDigitalOutputMode", _wrap_new_PropertyIDeviceDigitalOutputMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceDigitalOutputMode_getTranslationDict", _wrap_PropertyIDeviceDigitalOutputMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceDigitalOutputMode_getTranslationDictString", _wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceDigitalOutputMode_getTranslationDictValue", _wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceDigitalOutputMode_getTranslationDictStrings", _wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceDigitalOutputMode_getTranslationDictValues", _wrap_PropertyIDeviceDigitalOutputMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceDigitalOutputMode_getMaxValue", (PyCFunction)_wrap_PropertyIDeviceDigitalOutputMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceDigitalOutputMode_getMinValue", (PyCFunction)_wrap_PropertyIDeviceDigitalOutputMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceDigitalOutputMode_getStepWidth", (PyCFunction)_wrap_PropertyIDeviceDigitalOutputMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDeviceDigitalOutputMode_read", _wrap_PropertyIDeviceDigitalOutputMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceDigitalOutputMode_write", _wrap_PropertyIDeviceDigitalOutputMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDeviceDigitalOutputMode", (PyCFunction)_wrap_delete_PropertyIDeviceDigitalOutputMode, METH_O, NULL},
	 { (char *)"PropertyIDeviceDigitalOutputMode_swigregister", PropertyIDeviceDigitalOutputMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceDigitalOutputMode_swiginit", PropertyIDeviceDigitalOutputMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDeviceEventMode", _wrap_new_PropertyIDeviceEventMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceEventMode_getTranslationDict", _wrap_PropertyIDeviceEventMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceEventMode_getTranslationDictString", _wrap_PropertyIDeviceEventMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceEventMode_getTranslationDictValue", _wrap_PropertyIDeviceEventMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceEventMode_getTranslationDictStrings", _wrap_PropertyIDeviceEventMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceEventMode_getTranslationDictValues", _wrap_PropertyIDeviceEventMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceEventMode_getMaxValue", (PyCFunction)_wrap_PropertyIDeviceEventMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceEventMode_getMinValue", (PyCFunction)_wrap_PropertyIDeviceEventMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceEventMode_getStepWidth", (PyCFunction)_wrap_PropertyIDeviceEventMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDeviceEventMode_read", _wrap_PropertyIDeviceEventMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceEventMode_write", _wrap_PropertyIDeviceEventMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDeviceEventMode", (PyCFunction)_wrap_delete_PropertyIDeviceEventMode, METH_O, NULL},
	 { (char *)"PropertyIDeviceEventMode_swigregister", PropertyIDeviceEventMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceEventMode_swiginit", PropertyIDeviceEventMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDeviceEventType", _wrap_new_PropertyIDeviceEventType, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceEventType_getTranslationDict", _wrap_PropertyIDeviceEventType_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceEventType_getTranslationDictString", _wrap_PropertyIDeviceEventType_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceEventType_getTranslationDictValue", _wrap_PropertyIDeviceEventType_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceEventType_getTranslationDictStrings", _wrap_PropertyIDeviceEventType_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceEventType_getTranslationDictValues", _wrap_PropertyIDeviceEventType_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceEventType_getMaxValue", (PyCFunction)_wrap_PropertyIDeviceEventType_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceEventType_getMinValue", (PyCFunction)_wrap_PropertyIDeviceEventType_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceEventType_getStepWidth", (PyCFunction)_wrap_PropertyIDeviceEventType_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDeviceEventType_read", _wrap_PropertyIDeviceEventType_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceEventType_write", _wrap_PropertyIDeviceEventType_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDeviceEventType", (PyCFunction)_wrap_delete_PropertyIDeviceEventType, METH_O, NULL},
	 { (char *)"PropertyIDeviceEventType_swigregister", PropertyIDeviceEventType_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceEventType_swiginit", PropertyIDeviceEventType_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDeviceImageTrigger", _wrap_new_PropertyIDeviceImageTrigger, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceImageTrigger_getTranslationDict", _wrap_PropertyIDeviceImageTrigger_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceImageTrigger_getTranslationDictString", _wrap_PropertyIDeviceImageTrigger_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceImageTrigger_getTranslationDictValue", _wrap_PropertyIDeviceImageTrigger_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceImageTrigger_getTranslationDictStrings", _wrap_PropertyIDeviceImageTrigger_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceImageTrigger_getTranslationDictValues", _wrap_PropertyIDeviceImageTrigger_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceImageTrigger_getMaxValue", (PyCFunction)_wrap_PropertyIDeviceImageTrigger_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceImageTrigger_getMinValue", (PyCFunction)_wrap_PropertyIDeviceImageTrigger_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceImageTrigger_getStepWidth", (PyCFunction)_wrap_PropertyIDeviceImageTrigger_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDeviceImageTrigger_read", _wrap_PropertyIDeviceImageTrigger_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceImageTrigger_write", _wrap_PropertyIDeviceImageTrigger_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDeviceImageTrigger", (PyCFunction)_wrap_delete_PropertyIDeviceImageTrigger, METH_O, NULL},
	 { (char *)"PropertyIDeviceImageTrigger_swigregister", PropertyIDeviceImageTrigger_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceImageTrigger_swiginit", PropertyIDeviceImageTrigger_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDevicePowerMode", _wrap_new_PropertyIDevicePowerMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIDevicePowerMode_getTranslationDict", _wrap_PropertyIDevicePowerMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDevicePowerMode_getTranslationDictString", _wrap_PropertyIDevicePowerMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDevicePowerMode_getTranslationDictValue", _wrap_PropertyIDevicePowerMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDevicePowerMode_getTranslationDictStrings", _wrap_PropertyIDevicePowerMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDevicePowerMode_getTranslationDictValues", _wrap_PropertyIDevicePowerMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDevicePowerMode_getMaxValue", (PyCFunction)_wrap_PropertyIDevicePowerMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDevicePowerMode_getMinValue", (PyCFunction)_wrap_PropertyIDevicePowerMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDevicePowerMode_getStepWidth", (PyCFunction)_wrap_PropertyIDevicePowerMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDevicePowerMode_read", _wrap_PropertyIDevicePowerMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDevicePowerMode_write", _wrap_PropertyIDevicePowerMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDevicePowerMode", (PyCFunction)_wrap_delete_PropertyIDevicePowerMode, METH_O, NULL},
	 { (char *)"PropertyIDevicePowerMode_swigregister", PropertyIDevicePowerMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDevicePowerMode_swiginit", PropertyIDevicePowerMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDeviceScanRateMode", _wrap_new_PropertyIDeviceScanRateMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceScanRateMode_getTranslationDict", _wrap_PropertyIDeviceScanRateMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceScanRateMode_getTranslationDictString", _wrap_PropertyIDeviceScanRateMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceScanRateMode_getTranslationDictValue", _wrap_PropertyIDeviceScanRateMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceScanRateMode_getTranslationDictStrings", _wrap_PropertyIDeviceScanRateMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceScanRateMode_getTranslationDictValues", _wrap_PropertyIDeviceScanRateMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceScanRateMode_getMaxValue", (PyCFunction)_wrap_PropertyIDeviceScanRateMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceScanRateMode_getMinValue", (PyCFunction)_wrap_PropertyIDeviceScanRateMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceScanRateMode_getStepWidth", (PyCFunction)_wrap_PropertyIDeviceScanRateMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDeviceScanRateMode_read", _wrap_PropertyIDeviceScanRateMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceScanRateMode_write", _wrap_PropertyIDeviceScanRateMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDeviceScanRateMode", (PyCFunction)_wrap_delete_PropertyIDeviceScanRateMode, METH_O, NULL},
	 { (char *)"PropertyIDeviceScanRateMode_swigregister", PropertyIDeviceScanRateMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceScanRateMode_swiginit", PropertyIDeviceScanRateMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDeviceSignalOutputStartEvent", _wrap_new_PropertyIDeviceSignalOutputStartEvent, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceSignalOutputStartEvent_getTranslationDict", _wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceSignalOutputStartEvent_getTranslationDictString", _wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceSignalOutputStartEvent_getTranslationDictValue", _wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceSignalOutputStartEvent_getTranslationDictStrings", _wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceSignalOutputStartEvent_getTranslationDictValues", _wrap_PropertyIDeviceSignalOutputStartEvent_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceSignalOutputStartEvent_getMaxValue", (PyCFunction)_wrap_PropertyIDeviceSignalOutputStartEvent_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceSignalOutputStartEvent_getMinValue", (PyCFunction)_wrap_PropertyIDeviceSignalOutputStartEvent_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceSignalOutputStartEvent_getStepWidth", (PyCFunction)_wrap_PropertyIDeviceSignalOutputStartEvent_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDeviceSignalOutputStartEvent_read", _wrap_PropertyIDeviceSignalOutputStartEvent_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceSignalOutputStartEvent_write", _wrap_PropertyIDeviceSignalOutputStartEvent_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDeviceSignalOutputStartEvent", (PyCFunction)_wrap_delete_PropertyIDeviceSignalOutputStartEvent, METH_O, NULL},
	 { (char *)"PropertyIDeviceSignalOutputStartEvent_swigregister", PropertyIDeviceSignalOutputStartEvent_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceSignalOutputStartEvent_swiginit", PropertyIDeviceSignalOutputStartEvent_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDeviceSyncOutMode", _wrap_new_PropertyIDeviceSyncOutMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceSyncOutMode_getTranslationDict", _wrap_PropertyIDeviceSyncOutMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceSyncOutMode_getTranslationDictString", _wrap_PropertyIDeviceSyncOutMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceSyncOutMode_getTranslationDictValue", _wrap_PropertyIDeviceSyncOutMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceSyncOutMode_getTranslationDictStrings", _wrap_PropertyIDeviceSyncOutMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceSyncOutMode_getTranslationDictValues", _wrap_PropertyIDeviceSyncOutMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceSyncOutMode_getMaxValue", (PyCFunction)_wrap_PropertyIDeviceSyncOutMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceSyncOutMode_getMinValue", (PyCFunction)_wrap_PropertyIDeviceSyncOutMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceSyncOutMode_getStepWidth", (PyCFunction)_wrap_PropertyIDeviceSyncOutMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDeviceSyncOutMode_read", _wrap_PropertyIDeviceSyncOutMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceSyncOutMode_write", _wrap_PropertyIDeviceSyncOutMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDeviceSyncOutMode", (PyCFunction)_wrap_delete_PropertyIDeviceSyncOutMode, METH_O, NULL},
	 { (char *)"PropertyIDeviceSyncOutMode_swigregister", PropertyIDeviceSyncOutMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceSyncOutMode_swiginit", PropertyIDeviceSyncOutMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDeviceTriggerInterface", _wrap_new_PropertyIDeviceTriggerInterface, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceTriggerInterface_getTranslationDict", _wrap_PropertyIDeviceTriggerInterface_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceTriggerInterface_getTranslationDictString", _wrap_PropertyIDeviceTriggerInterface_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceTriggerInterface_getTranslationDictValue", _wrap_PropertyIDeviceTriggerInterface_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceTriggerInterface_getTranslationDictStrings", _wrap_PropertyIDeviceTriggerInterface_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceTriggerInterface_getTranslationDictValues", _wrap_PropertyIDeviceTriggerInterface_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceTriggerInterface_getMaxValue", (PyCFunction)_wrap_PropertyIDeviceTriggerInterface_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceTriggerInterface_getMinValue", (PyCFunction)_wrap_PropertyIDeviceTriggerInterface_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceTriggerInterface_getStepWidth", (PyCFunction)_wrap_PropertyIDeviceTriggerInterface_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDeviceTriggerInterface_read", _wrap_PropertyIDeviceTriggerInterface_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceTriggerInterface_write", _wrap_PropertyIDeviceTriggerInterface_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDeviceTriggerInterface", (PyCFunction)_wrap_delete_PropertyIDeviceTriggerInterface, METH_O, NULL},
	 { (char *)"PropertyIDeviceTriggerInterface_swigregister", PropertyIDeviceTriggerInterface_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceTriggerInterface_swiginit", PropertyIDeviceTriggerInterface_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDeviceTriggerMode", _wrap_new_PropertyIDeviceTriggerMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceTriggerMode_getTranslationDict", _wrap_PropertyIDeviceTriggerMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceTriggerMode_getTranslationDictString", _wrap_PropertyIDeviceTriggerMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceTriggerMode_getTranslationDictValue", _wrap_PropertyIDeviceTriggerMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceTriggerMode_getTranslationDictStrings", _wrap_PropertyIDeviceTriggerMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceTriggerMode_getTranslationDictValues", _wrap_PropertyIDeviceTriggerMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceTriggerMode_getMaxValue", (PyCFunction)_wrap_PropertyIDeviceTriggerMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceTriggerMode_getMinValue", (PyCFunction)_wrap_PropertyIDeviceTriggerMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDeviceTriggerMode_getStepWidth", (PyCFunction)_wrap_PropertyIDeviceTriggerMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDeviceTriggerMode_read", _wrap_PropertyIDeviceTriggerMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceTriggerMode_write", _wrap_PropertyIDeviceTriggerMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDeviceTriggerMode", (PyCFunction)_wrap_delete_PropertyIDeviceTriggerMode, METH_O, NULL},
	 { (char *)"PropertyIDeviceTriggerMode_swigregister", PropertyIDeviceTriggerMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDeviceTriggerMode_swiginit", PropertyIDeviceTriggerMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDigIOState", _wrap_new_PropertyIDigIOState, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigIOState_getTranslationDict", _wrap_PropertyIDigIOState_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigIOState_getTranslationDictString", _wrap_PropertyIDigIOState_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigIOState_getTranslationDictValue", _wrap_PropertyIDigIOState_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigIOState_getTranslationDictStrings", _wrap_PropertyIDigIOState_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigIOState_getTranslationDictValues", _wrap_PropertyIDigIOState_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigIOState_getMaxValue", (PyCFunction)_wrap_PropertyIDigIOState_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDigIOState_getMinValue", (PyCFunction)_wrap_PropertyIDigIOState_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDigIOState_getStepWidth", (PyCFunction)_wrap_PropertyIDigIOState_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDigIOState_read", _wrap_PropertyIDigIOState_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigIOState_write", _wrap_PropertyIDigIOState_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDigIOState", (PyCFunction)_wrap_delete_PropertyIDigIOState, METH_O, NULL},
	 { (char *)"PropertyIDigIOState_swigregister", PropertyIDigIOState_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigIOState_swiginit", PropertyIDigIOState_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDigitalIOMeasurementMode", _wrap_new_PropertyIDigitalIOMeasurementMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementMode_getTranslationDict", _wrap_PropertyIDigitalIOMeasurementMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementMode_getTranslationDictString", _wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementMode_getTranslationDictValue", _wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementMode_getTranslationDictStrings", _wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementMode_getTranslationDictValues", _wrap_PropertyIDigitalIOMeasurementMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementMode_getMaxValue", (PyCFunction)_wrap_PropertyIDigitalIOMeasurementMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementMode_getMinValue", (PyCFunction)_wrap_PropertyIDigitalIOMeasurementMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementMode_getStepWidth", (PyCFunction)_wrap_PropertyIDigitalIOMeasurementMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementMode_read", _wrap_PropertyIDigitalIOMeasurementMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementMode_write", _wrap_PropertyIDigitalIOMeasurementMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDigitalIOMeasurementMode", (PyCFunction)_wrap_delete_PropertyIDigitalIOMeasurementMode, METH_O, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementMode_swigregister", PropertyIDigitalIOMeasurementMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementMode_swiginit", PropertyIDigitalIOMeasurementMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDigitalIOMeasurementSource", _wrap_new_PropertyIDigitalIOMeasurementSource, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementSource_getTranslationDict", _wrap_PropertyIDigitalIOMeasurementSource_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementSource_getTranslationDictString", _wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementSource_getTranslationDictValue", _wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementSource_getTranslationDictStrings", _wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementSource_getTranslationDictValues", _wrap_PropertyIDigitalIOMeasurementSource_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementSource_getMaxValue", (PyCFunction)_wrap_PropertyIDigitalIOMeasurementSource_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementSource_getMinValue", (PyCFunction)_wrap_PropertyIDigitalIOMeasurementSource_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementSource_getStepWidth", (PyCFunction)_wrap_PropertyIDigitalIOMeasurementSource_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementSource_read", _wrap_PropertyIDigitalIOMeasurementSource_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementSource_write", _wrap_PropertyIDigitalIOMeasurementSource_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDigitalIOMeasurementSource", (PyCFunction)_wrap_delete_PropertyIDigitalIOMeasurementSource, METH_O, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementSource_swigregister", PropertyIDigitalIOMeasurementSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalIOMeasurementSource_swiginit", PropertyIDigitalIOMeasurementSource_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDigitalOutputControlMode", _wrap_new_PropertyIDigitalOutputControlMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalOutputControlMode_getTranslationDict", _wrap_PropertyIDigitalOutputControlMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalOutputControlMode_getTranslationDictString", _wrap_PropertyIDigitalOutputControlMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalOutputControlMode_getTranslationDictValue", _wrap_PropertyIDigitalOutputControlMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalOutputControlMode_getTranslationDictStrings", _wrap_PropertyIDigitalOutputControlMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalOutputControlMode_getTranslationDictValues", _wrap_PropertyIDigitalOutputControlMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalOutputControlMode_getMaxValue", (PyCFunction)_wrap_PropertyIDigitalOutputControlMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDigitalOutputControlMode_getMinValue", (PyCFunction)_wrap_PropertyIDigitalOutputControlMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDigitalOutputControlMode_getStepWidth", (PyCFunction)_wrap_PropertyIDigitalOutputControlMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDigitalOutputControlMode_read", _wrap_PropertyIDigitalOutputControlMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalOutputControlMode_write", _wrap_PropertyIDigitalOutputControlMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDigitalOutputControlMode", (PyCFunction)_wrap_delete_PropertyIDigitalOutputControlMode, METH_O, NULL},
	 { (char *)"PropertyIDigitalOutputControlMode_swigregister", PropertyIDigitalOutputControlMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalOutputControlMode_swiginit", PropertyIDigitalOutputControlMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIDigitalSignal", _wrap_new_PropertyIDigitalSignal, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalSignal_getTranslationDict", _wrap_PropertyIDigitalSignal_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalSignal_getTranslationDictString", _wrap_PropertyIDigitalSignal_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalSignal_getTranslationDictValue", _wrap_PropertyIDigitalSignal_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalSignal_getTranslationDictStrings", _wrap_PropertyIDigitalSignal_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalSignal_getTranslationDictValues", _wrap_PropertyIDigitalSignal_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalSignal_getMaxValue", (PyCFunction)_wrap_PropertyIDigitalSignal_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIDigitalSignal_getMinValue", (PyCFunction)_wrap_PropertyIDigitalSignal_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIDigitalSignal_getStepWidth", (PyCFunction)_wrap_PropertyIDigitalSignal_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIDigitalSignal_read", _wrap_PropertyIDigitalSignal_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalSignal_write", _wrap_PropertyIDigitalSignal_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIDigitalSignal", (PyCFunction)_wrap_delete_PropertyIDigitalSignal, METH_O, NULL},
	 { (char *)"PropertyIDigitalSignal_swigregister", PropertyIDigitalSignal_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIDigitalSignal_swiginit", PropertyIDigitalSignal_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIFieldGateMode", _wrap_new_PropertyIFieldGateMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIFieldGateMode_getTranslationDict", _wrap_PropertyIFieldGateMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIFieldGateMode_getTranslationDictString", _wrap_PropertyIFieldGateMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIFieldGateMode_getTranslationDictValue", _wrap_PropertyIFieldGateMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIFieldGateMode_getTranslationDictStrings", _wrap_PropertyIFieldGateMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIFieldGateMode_getTranslationDictValues", _wrap_PropertyIFieldGateMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIFieldGateMode_getMaxValue", (PyCFunction)_wrap_PropertyIFieldGateMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIFieldGateMode_getMinValue", (PyCFunction)_wrap_PropertyIFieldGateMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIFieldGateMode_getStepWidth", (PyCFunction)_wrap_PropertyIFieldGateMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIFieldGateMode_read", _wrap_PropertyIFieldGateMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIFieldGateMode_write", _wrap_PropertyIFieldGateMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIFieldGateMode", (PyCFunction)_wrap_delete_PropertyIFieldGateMode, METH_O, NULL},
	 { (char *)"PropertyIFieldGateMode_swigregister", PropertyIFieldGateMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIFieldGateMode_swiginit", PropertyIFieldGateMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyII2COperationMode", _wrap_new_PropertyII2COperationMode, METH_VARARGS, NULL},
	 { (char *)"PropertyII2COperationMode_getTranslationDict", _wrap_PropertyII2COperationMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyII2COperationMode_getTranslationDictString", _wrap_PropertyII2COperationMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyII2COperationMode_getTranslationDictValue", _wrap_PropertyII2COperationMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyII2COperationMode_getTranslationDictStrings", _wrap_PropertyII2COperationMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyII2COperationMode_getTranslationDictValues", _wrap_PropertyII2COperationMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyII2COperationMode_getMaxValue", (PyCFunction)_wrap_PropertyII2COperationMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyII2COperationMode_getMinValue", (PyCFunction)_wrap_PropertyII2COperationMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyII2COperationMode_getStepWidth", (PyCFunction)_wrap_PropertyII2COperationMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyII2COperationMode_read", _wrap_PropertyII2COperationMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyII2COperationMode_write", _wrap_PropertyII2COperationMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyII2COperationMode", (PyCFunction)_wrap_delete_PropertyII2COperationMode, METH_O, NULL},
	 { (char *)"PropertyII2COperationMode_swigregister", PropertyII2COperationMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyII2COperationMode_swiginit", PropertyII2COperationMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyII2COperationStatus", _wrap_new_PropertyII2COperationStatus, METH_VARARGS, NULL},
	 { (char *)"PropertyII2COperationStatus_getTranslationDict", _wrap_PropertyII2COperationStatus_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyII2COperationStatus_getTranslationDictString", _wrap_PropertyII2COperationStatus_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyII2COperationStatus_getTranslationDictValue", _wrap_PropertyII2COperationStatus_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyII2COperationStatus_getTranslationDictStrings", _wrap_PropertyII2COperationStatus_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyII2COperationStatus_getTranslationDictValues", _wrap_PropertyII2COperationStatus_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyII2COperationStatus_getMaxValue", (PyCFunction)_wrap_PropertyII2COperationStatus_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyII2COperationStatus_getMinValue", (PyCFunction)_wrap_PropertyII2COperationStatus_getMinValue, METH_O, NULL},
	 { (char *)"PropertyII2COperationStatus_getStepWidth", (PyCFunction)_wrap_PropertyII2COperationStatus_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyII2COperationStatus_read", _wrap_PropertyII2COperationStatus_read, METH_VARARGS, NULL},
	 { (char *)"PropertyII2COperationStatus_write", _wrap_PropertyII2COperationStatus_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyII2COperationStatus", (PyCFunction)_wrap_delete_PropertyII2COperationStatus, METH_O, NULL},
	 { (char *)"PropertyII2COperationStatus_swigregister", PropertyII2COperationStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyII2COperationStatus_swiginit", PropertyII2COperationStatus_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIInfoSensorColorMode", _wrap_new_PropertyIInfoSensorColorMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIInfoSensorColorMode_getTranslationDict", _wrap_PropertyIInfoSensorColorMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIInfoSensorColorMode_getTranslationDictString", _wrap_PropertyIInfoSensorColorMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIInfoSensorColorMode_getTranslationDictValue", _wrap_PropertyIInfoSensorColorMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIInfoSensorColorMode_getTranslationDictStrings", _wrap_PropertyIInfoSensorColorMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIInfoSensorColorMode_getTranslationDictValues", _wrap_PropertyIInfoSensorColorMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIInfoSensorColorMode_getMaxValue", (PyCFunction)_wrap_PropertyIInfoSensorColorMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIInfoSensorColorMode_getMinValue", (PyCFunction)_wrap_PropertyIInfoSensorColorMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIInfoSensorColorMode_getStepWidth", (PyCFunction)_wrap_PropertyIInfoSensorColorMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIInfoSensorColorMode_read", _wrap_PropertyIInfoSensorColorMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIInfoSensorColorMode_write", _wrap_PropertyIInfoSensorColorMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIInfoSensorColorMode", (PyCFunction)_wrap_delete_PropertyIInfoSensorColorMode, METH_O, NULL},
	 { (char *)"PropertyIInfoSensorColorMode_swigregister", PropertyIInfoSensorColorMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIInfoSensorColorMode_swiginit", PropertyIInfoSensorColorMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIInfoSensorType", _wrap_new_PropertyIInfoSensorType, METH_VARARGS, NULL},
	 { (char *)"PropertyIInfoSensorType_getTranslationDict", _wrap_PropertyIInfoSensorType_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIInfoSensorType_getTranslationDictString", _wrap_PropertyIInfoSensorType_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIInfoSensorType_getTranslationDictValue", _wrap_PropertyIInfoSensorType_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIInfoSensorType_getTranslationDictStrings", _wrap_PropertyIInfoSensorType_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIInfoSensorType_getTranslationDictValues", _wrap_PropertyIInfoSensorType_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIInfoSensorType_getMaxValue", (PyCFunction)_wrap_PropertyIInfoSensorType_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIInfoSensorType_getMinValue", (PyCFunction)_wrap_PropertyIInfoSensorType_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIInfoSensorType_getStepWidth", (PyCFunction)_wrap_PropertyIInfoSensorType_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIInfoSensorType_read", _wrap_PropertyIInfoSensorType_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIInfoSensorType_write", _wrap_PropertyIInfoSensorType_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIInfoSensorType", (PyCFunction)_wrap_delete_PropertyIInfoSensorType, METH_O, NULL},
	 { (char *)"PropertyIInfoSensorType_swigregister", PropertyIInfoSensorType_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIInfoSensorType_swiginit", PropertyIInfoSensorType_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIInterlacedMode", _wrap_new_PropertyIInterlacedMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIInterlacedMode_getTranslationDict", _wrap_PropertyIInterlacedMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIInterlacedMode_getTranslationDictString", _wrap_PropertyIInterlacedMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIInterlacedMode_getTranslationDictValue", _wrap_PropertyIInterlacedMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIInterlacedMode_getTranslationDictStrings", _wrap_PropertyIInterlacedMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIInterlacedMode_getTranslationDictValues", _wrap_PropertyIInterlacedMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIInterlacedMode_getMaxValue", (PyCFunction)_wrap_PropertyIInterlacedMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIInterlacedMode_getMinValue", (PyCFunction)_wrap_PropertyIInterlacedMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIInterlacedMode_getStepWidth", (PyCFunction)_wrap_PropertyIInterlacedMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIInterlacedMode_read", _wrap_PropertyIInterlacedMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIInterlacedMode_write", _wrap_PropertyIInterlacedMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIInterlacedMode", (PyCFunction)_wrap_delete_PropertyIInterlacedMode, METH_O, NULL},
	 { (char *)"PropertyIInterlacedMode_swigregister", PropertyIInterlacedMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIInterlacedMode_swiginit", PropertyIInterlacedMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyILineCounter", _wrap_new_PropertyILineCounter, METH_VARARGS, NULL},
	 { (char *)"PropertyILineCounter_getTranslationDict", _wrap_PropertyILineCounter_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyILineCounter_getTranslationDictString", _wrap_PropertyILineCounter_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyILineCounter_getTranslationDictValue", _wrap_PropertyILineCounter_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyILineCounter_getTranslationDictStrings", _wrap_PropertyILineCounter_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyILineCounter_getTranslationDictValues", _wrap_PropertyILineCounter_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyILineCounter_getMaxValue", (PyCFunction)_wrap_PropertyILineCounter_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyILineCounter_getMinValue", (PyCFunction)_wrap_PropertyILineCounter_getMinValue, METH_O, NULL},
	 { (char *)"PropertyILineCounter_getStepWidth", (PyCFunction)_wrap_PropertyILineCounter_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyILineCounter_read", _wrap_PropertyILineCounter_read, METH_VARARGS, NULL},
	 { (char *)"PropertyILineCounter_write", _wrap_PropertyILineCounter_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyILineCounter", (PyCFunction)_wrap_delete_PropertyILineCounter, METH_O, NULL},
	 { (char *)"PropertyILineCounter_swigregister", PropertyILineCounter_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyILineCounter_swiginit", PropertyILineCounter_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIMemoryManagerMode", _wrap_new_PropertyIMemoryManagerMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIMemoryManagerMode_getTranslationDict", _wrap_PropertyIMemoryManagerMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIMemoryManagerMode_getTranslationDictString", _wrap_PropertyIMemoryManagerMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIMemoryManagerMode_getTranslationDictValue", _wrap_PropertyIMemoryManagerMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIMemoryManagerMode_getTranslationDictStrings", _wrap_PropertyIMemoryManagerMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIMemoryManagerMode_getTranslationDictValues", _wrap_PropertyIMemoryManagerMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIMemoryManagerMode_getMaxValue", (PyCFunction)_wrap_PropertyIMemoryManagerMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIMemoryManagerMode_getMinValue", (PyCFunction)_wrap_PropertyIMemoryManagerMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIMemoryManagerMode_getStepWidth", (PyCFunction)_wrap_PropertyIMemoryManagerMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIMemoryManagerMode_read", _wrap_PropertyIMemoryManagerMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIMemoryManagerMode_write", _wrap_PropertyIMemoryManagerMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIMemoryManagerMode", (PyCFunction)_wrap_delete_PropertyIMemoryManagerMode, METH_O, NULL},
	 { (char *)"PropertyIMemoryManagerMode_swigregister", PropertyIMemoryManagerMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIMemoryManagerMode_swiginit", PropertyIMemoryManagerMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIMemoryManagerPoolMode", _wrap_new_PropertyIMemoryManagerPoolMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIMemoryManagerPoolMode_getTranslationDict", _wrap_PropertyIMemoryManagerPoolMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIMemoryManagerPoolMode_getTranslationDictString", _wrap_PropertyIMemoryManagerPoolMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIMemoryManagerPoolMode_getTranslationDictValue", _wrap_PropertyIMemoryManagerPoolMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIMemoryManagerPoolMode_getTranslationDictStrings", _wrap_PropertyIMemoryManagerPoolMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIMemoryManagerPoolMode_getTranslationDictValues", _wrap_PropertyIMemoryManagerPoolMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIMemoryManagerPoolMode_getMaxValue", (PyCFunction)_wrap_PropertyIMemoryManagerPoolMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIMemoryManagerPoolMode_getMinValue", (PyCFunction)_wrap_PropertyIMemoryManagerPoolMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIMemoryManagerPoolMode_getStepWidth", (PyCFunction)_wrap_PropertyIMemoryManagerPoolMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIMemoryManagerPoolMode_read", _wrap_PropertyIMemoryManagerPoolMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIMemoryManagerPoolMode_write", _wrap_PropertyIMemoryManagerPoolMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIMemoryManagerPoolMode", (PyCFunction)_wrap_delete_PropertyIMemoryManagerPoolMode, METH_O, NULL},
	 { (char *)"PropertyIMemoryManagerPoolMode_swigregister", PropertyIMemoryManagerPoolMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIMemoryManagerPoolMode_swiginit", PropertyIMemoryManagerPoolMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIOnBoardMemoryMode", _wrap_new_PropertyIOnBoardMemoryMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIOnBoardMemoryMode_getTranslationDict", _wrap_PropertyIOnBoardMemoryMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIOnBoardMemoryMode_getTranslationDictString", _wrap_PropertyIOnBoardMemoryMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIOnBoardMemoryMode_getTranslationDictValue", _wrap_PropertyIOnBoardMemoryMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIOnBoardMemoryMode_getTranslationDictStrings", _wrap_PropertyIOnBoardMemoryMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIOnBoardMemoryMode_getTranslationDictValues", _wrap_PropertyIOnBoardMemoryMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIOnBoardMemoryMode_getMaxValue", (PyCFunction)_wrap_PropertyIOnBoardMemoryMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIOnBoardMemoryMode_getMinValue", (PyCFunction)_wrap_PropertyIOnBoardMemoryMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIOnBoardMemoryMode_getStepWidth", (PyCFunction)_wrap_PropertyIOnBoardMemoryMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIOnBoardMemoryMode_read", _wrap_PropertyIOnBoardMemoryMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIOnBoardMemoryMode_write", _wrap_PropertyIOnBoardMemoryMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIOnBoardMemoryMode", (PyCFunction)_wrap_delete_PropertyIOnBoardMemoryMode, METH_O, NULL},
	 { (char *)"PropertyIOnBoardMemoryMode_swigregister", PropertyIOnBoardMemoryMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIOnBoardMemoryMode_swiginit", PropertyIOnBoardMemoryMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIPulseStartTrigger", _wrap_new_PropertyIPulseStartTrigger, METH_VARARGS, NULL},
	 { (char *)"PropertyIPulseStartTrigger_getTranslationDict", _wrap_PropertyIPulseStartTrigger_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIPulseStartTrigger_getTranslationDictString", _wrap_PropertyIPulseStartTrigger_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIPulseStartTrigger_getTranslationDictValue", _wrap_PropertyIPulseStartTrigger_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIPulseStartTrigger_getTranslationDictStrings", _wrap_PropertyIPulseStartTrigger_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIPulseStartTrigger_getTranslationDictValues", _wrap_PropertyIPulseStartTrigger_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIPulseStartTrigger_getMaxValue", (PyCFunction)_wrap_PropertyIPulseStartTrigger_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIPulseStartTrigger_getMinValue", (PyCFunction)_wrap_PropertyIPulseStartTrigger_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIPulseStartTrigger_getStepWidth", (PyCFunction)_wrap_PropertyIPulseStartTrigger_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIPulseStartTrigger_read", _wrap_PropertyIPulseStartTrigger_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIPulseStartTrigger_write", _wrap_PropertyIPulseStartTrigger_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIPulseStartTrigger", (PyCFunction)_wrap_delete_PropertyIPulseStartTrigger, METH_O, NULL},
	 { (char *)"PropertyIPulseStartTrigger_swigregister", PropertyIPulseStartTrigger_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIPulseStartTrigger_swiginit", PropertyIPulseStartTrigger_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIRTCtrlModes", _wrap_new_PropertyIRTCtrlModes, METH_VARARGS, NULL},
	 { (char *)"PropertyIRTCtrlModes_getTranslationDict", _wrap_PropertyIRTCtrlModes_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIRTCtrlModes_getTranslationDictString", _wrap_PropertyIRTCtrlModes_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIRTCtrlModes_getTranslationDictValue", _wrap_PropertyIRTCtrlModes_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIRTCtrlModes_getTranslationDictStrings", _wrap_PropertyIRTCtrlModes_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIRTCtrlModes_getTranslationDictValues", _wrap_PropertyIRTCtrlModes_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIRTCtrlModes_getMaxValue", (PyCFunction)_wrap_PropertyIRTCtrlModes_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIRTCtrlModes_getMinValue", (PyCFunction)_wrap_PropertyIRTCtrlModes_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIRTCtrlModes_getStepWidth", (PyCFunction)_wrap_PropertyIRTCtrlModes_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIRTCtrlModes_read", _wrap_PropertyIRTCtrlModes_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIRTCtrlModes_write", _wrap_PropertyIRTCtrlModes_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIRTCtrlModes", (PyCFunction)_wrap_delete_PropertyIRTCtrlModes, METH_O, NULL},
	 { (char *)"PropertyIRTCtrlModes_swigregister", PropertyIRTCtrlModes_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIRTCtrlModes_swiginit", PropertyIRTCtrlModes_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIRTProgOpCodes", _wrap_new_PropertyIRTProgOpCodes, METH_VARARGS, NULL},
	 { (char *)"PropertyIRTProgOpCodes_getTranslationDict", _wrap_PropertyIRTProgOpCodes_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIRTProgOpCodes_getTranslationDictString", _wrap_PropertyIRTProgOpCodes_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIRTProgOpCodes_getTranslationDictValue", _wrap_PropertyIRTProgOpCodes_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIRTProgOpCodes_getTranslationDictStrings", _wrap_PropertyIRTProgOpCodes_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIRTProgOpCodes_getTranslationDictValues", _wrap_PropertyIRTProgOpCodes_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIRTProgOpCodes_getMaxValue", (PyCFunction)_wrap_PropertyIRTProgOpCodes_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIRTProgOpCodes_getMinValue", (PyCFunction)_wrap_PropertyIRTProgOpCodes_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIRTProgOpCodes_getStepWidth", (PyCFunction)_wrap_PropertyIRTProgOpCodes_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIRTProgOpCodes_read", _wrap_PropertyIRTProgOpCodes_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIRTProgOpCodes_write", _wrap_PropertyIRTProgOpCodes_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIRTProgOpCodes", (PyCFunction)_wrap_delete_PropertyIRTProgOpCodes, METH_O, NULL},
	 { (char *)"PropertyIRTProgOpCodes_swigregister", PropertyIRTProgOpCodes_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIRTProgOpCodes_swiginit", PropertyIRTProgOpCodes_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIScanClock", _wrap_new_PropertyIScanClock, METH_VARARGS, NULL},
	 { (char *)"PropertyIScanClock_getTranslationDict", _wrap_PropertyIScanClock_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIScanClock_getTranslationDictString", _wrap_PropertyIScanClock_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIScanClock_getTranslationDictValue", _wrap_PropertyIScanClock_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIScanClock_getTranslationDictStrings", _wrap_PropertyIScanClock_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIScanClock_getTranslationDictValues", _wrap_PropertyIScanClock_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIScanClock_getMaxValue", (PyCFunction)_wrap_PropertyIScanClock_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIScanClock_getMinValue", (PyCFunction)_wrap_PropertyIScanClock_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIScanClock_getStepWidth", (PyCFunction)_wrap_PropertyIScanClock_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIScanClock_read", _wrap_PropertyIScanClock_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIScanClock_write", _wrap_PropertyIScanClock_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIScanClock", (PyCFunction)_wrap_delete_PropertyIScanClock, METH_O, NULL},
	 { (char *)"PropertyIScanClock_swigregister", PropertyIScanClock_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIScanClock_swiginit", PropertyIScanClock_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIScanStandard", _wrap_new_PropertyIScanStandard, METH_VARARGS, NULL},
	 { (char *)"PropertyIScanStandard_getTranslationDict", _wrap_PropertyIScanStandard_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIScanStandard_getTranslationDictString", _wrap_PropertyIScanStandard_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIScanStandard_getTranslationDictValue", _wrap_PropertyIScanStandard_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIScanStandard_getTranslationDictStrings", _wrap_PropertyIScanStandard_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIScanStandard_getTranslationDictValues", _wrap_PropertyIScanStandard_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIScanStandard_getMaxValue", (PyCFunction)_wrap_PropertyIScanStandard_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIScanStandard_getMinValue", (PyCFunction)_wrap_PropertyIScanStandard_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIScanStandard_getStepWidth", (PyCFunction)_wrap_PropertyIScanStandard_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIScanStandard_read", _wrap_PropertyIScanStandard_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIScanStandard_write", _wrap_PropertyIScanStandard_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIScanStandard", (PyCFunction)_wrap_delete_PropertyIScanStandard, METH_O, NULL},
	 { (char *)"PropertyIScanStandard_swigregister", PropertyIScanStandard_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIScanStandard_swiginit", PropertyIScanStandard_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyITriggerMoment", _wrap_new_PropertyITriggerMoment, METH_VARARGS, NULL},
	 { (char *)"PropertyITriggerMoment_getTranslationDict", _wrap_PropertyITriggerMoment_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyITriggerMoment_getTranslationDictString", _wrap_PropertyITriggerMoment_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyITriggerMoment_getTranslationDictValue", _wrap_PropertyITriggerMoment_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyITriggerMoment_getTranslationDictStrings", _wrap_PropertyITriggerMoment_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyITriggerMoment_getTranslationDictValues", _wrap_PropertyITriggerMoment_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyITriggerMoment_getMaxValue", (PyCFunction)_wrap_PropertyITriggerMoment_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyITriggerMoment_getMinValue", (PyCFunction)_wrap_PropertyITriggerMoment_getMinValue, METH_O, NULL},
	 { (char *)"PropertyITriggerMoment_getStepWidth", (PyCFunction)_wrap_PropertyITriggerMoment_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyITriggerMoment_read", _wrap_PropertyITriggerMoment_read, METH_VARARGS, NULL},
	 { (char *)"PropertyITriggerMoment_write", _wrap_PropertyITriggerMoment_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyITriggerMoment", (PyCFunction)_wrap_delete_PropertyITriggerMoment, METH_O, NULL},
	 { (char *)"PropertyITriggerMoment_swigregister", PropertyITriggerMoment_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyITriggerMoment_swiginit", PropertyITriggerMoment_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIVideoStandard", _wrap_new_PropertyIVideoStandard, METH_VARARGS, NULL},
	 { (char *)"PropertyIVideoStandard_getTranslationDict", _wrap_PropertyIVideoStandard_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIVideoStandard_getTranslationDictString", _wrap_PropertyIVideoStandard_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIVideoStandard_getTranslationDictValue", _wrap_PropertyIVideoStandard_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIVideoStandard_getTranslationDictStrings", _wrap_PropertyIVideoStandard_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIVideoStandard_getTranslationDictValues", _wrap_PropertyIVideoStandard_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIVideoStandard_getMaxValue", (PyCFunction)_wrap_PropertyIVideoStandard_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIVideoStandard_getMinValue", (PyCFunction)_wrap_PropertyIVideoStandard_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIVideoStandard_getStepWidth", (PyCFunction)_wrap_PropertyIVideoStandard_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIVideoStandard_read", _wrap_PropertyIVideoStandard_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIVideoStandard_write", _wrap_PropertyIVideoStandard_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIVideoStandard", (PyCFunction)_wrap_delete_PropertyIVideoStandard, METH_O, NULL},
	 { (char *)"PropertyIVideoStandard_swigregister", PropertyIVideoStandard_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIVideoStandard_swiginit", PropertyIVideoStandard_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIVirtualDeviceImageType", _wrap_new_PropertyIVirtualDeviceImageType, METH_VARARGS, NULL},
	 { (char *)"PropertyIVirtualDeviceImageType_getTranslationDict", _wrap_PropertyIVirtualDeviceImageType_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIVirtualDeviceImageType_getTranslationDictString", _wrap_PropertyIVirtualDeviceImageType_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIVirtualDeviceImageType_getTranslationDictValue", _wrap_PropertyIVirtualDeviceImageType_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIVirtualDeviceImageType_getTranslationDictStrings", _wrap_PropertyIVirtualDeviceImageType_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIVirtualDeviceImageType_getTranslationDictValues", _wrap_PropertyIVirtualDeviceImageType_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIVirtualDeviceImageType_getMaxValue", (PyCFunction)_wrap_PropertyIVirtualDeviceImageType_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIVirtualDeviceImageType_getMinValue", (PyCFunction)_wrap_PropertyIVirtualDeviceImageType_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIVirtualDeviceImageType_getStepWidth", (PyCFunction)_wrap_PropertyIVirtualDeviceImageType_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIVirtualDeviceImageType_read", _wrap_PropertyIVirtualDeviceImageType_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIVirtualDeviceImageType_write", _wrap_PropertyIVirtualDeviceImageType_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIVirtualDeviceImageType", (PyCFunction)_wrap_delete_PropertyIVirtualDeviceImageType, METH_O, NULL},
	 { (char *)"PropertyIVirtualDeviceImageType_swigregister", PropertyIVirtualDeviceImageType_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIVirtualDeviceImageType_swiginit", PropertyIVirtualDeviceImageType_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_PropertyIVirtualDeviceTestMode", _wrap_new_PropertyIVirtualDeviceTestMode, METH_VARARGS, NULL},
	 { (char *)"PropertyIVirtualDeviceTestMode_getTranslationDict", _wrap_PropertyIVirtualDeviceTestMode_getTranslationDict, METH_VARARGS, NULL},
	 { (char *)"PropertyIVirtualDeviceTestMode_getTranslationDictString", _wrap_PropertyIVirtualDeviceTestMode_getTranslationDictString, METH_VARARGS, NULL},
	 { (char *)"PropertyIVirtualDeviceTestMode_getTranslationDictValue", _wrap_PropertyIVirtualDeviceTestMode_getTranslationDictValue, METH_VARARGS, NULL},
	 { (char *)"PropertyIVirtualDeviceTestMode_getTranslationDictStrings", _wrap_PropertyIVirtualDeviceTestMode_getTranslationDictStrings, METH_VARARGS, NULL},
	 { (char *)"PropertyIVirtualDeviceTestMode_getTranslationDictValues", _wrap_PropertyIVirtualDeviceTestMode_getTranslationDictValues, METH_VARARGS, NULL},
	 { (char *)"PropertyIVirtualDeviceTestMode_getMaxValue", (PyCFunction)_wrap_PropertyIVirtualDeviceTestMode_getMaxValue, METH_O, NULL},
	 { (char *)"PropertyIVirtualDeviceTestMode_getMinValue", (PyCFunction)_wrap_PropertyIVirtualDeviceTestMode_getMinValue, METH_O, NULL},
	 { (char *)"PropertyIVirtualDeviceTestMode_getStepWidth", (PyCFunction)_wrap_PropertyIVirtualDeviceTestMode_getStepWidth, METH_O, NULL},
	 { (char *)"PropertyIVirtualDeviceTestMode_read", _wrap_PropertyIVirtualDeviceTestMode_read, METH_VARARGS, NULL},
	 { (char *)"PropertyIVirtualDeviceTestMode_write", _wrap_PropertyIVirtualDeviceTestMode_write, METH_VARARGS, NULL},
	 { (char *)"delete_PropertyIVirtualDeviceTestMode", (PyCFunction)_wrap_delete_PropertyIVirtualDeviceTestMode, METH_O, NULL},
	 { (char *)"PropertyIVirtualDeviceTestMode_swigregister", PropertyIVirtualDeviceTestMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"PropertyIVirtualDeviceTestMode_swiginit", PropertyIVirtualDeviceTestMode_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ImageMemoryManager", (PyCFunction)_wrap_new_ImageMemoryManager, METH_O, NULL},
	 { (char *)"ImageMemoryManager_mode_get", (PyCFunction)_wrap_ImageMemoryManager_mode_get, METH_O, NULL},
	 { (char *)"ImageMemoryManager_allocatedDMAMemory_bytes_get", (PyCFunction)_wrap_ImageMemoryManager_allocatedDMAMemory_bytes_get, METH_O, NULL},
	 { (char *)"ImageMemoryManager_usedDMAMemory_bytes_get", (PyCFunction)_wrap_ImageMemoryManager_usedDMAMemory_bytes_get, METH_O, NULL},
	 { (char *)"ImageMemoryManager_usedBlocks_get", (PyCFunction)_wrap_ImageMemoryManager_usedBlocks_get, METH_O, NULL},
	 { (char *)"ImageMemoryManager_poolMode_get", (PyCFunction)_wrap_ImageMemoryManager_poolMode_get, METH_O, NULL},
	 { (char *)"ImageMemoryManager_poolBlockSize_bytes_get", (PyCFunction)_wrap_ImageMemoryManager_poolBlockSize_bytes_get, METH_O, NULL},
	 { (char *)"ImageMemoryManager_poolBlockCount_get", (PyCFunction)_wrap_ImageMemoryManager_poolBlockCount_get, METH_O, NULL},
	 { (char *)"delete_ImageMemoryManager", (PyCFunction)_wrap_delete_ImageMemoryManager, METH_O, NULL},
	 { (char *)"ImageMemoryManager_swigregister", ImageMemoryManager_swigregister, METH_VARARGS, NULL},
	 { (char *)"ImageMemoryManager_swiginit", ImageMemoryManager_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_InfoBlueDevice", (PyCFunction)_wrap_new_InfoBlueDevice, METH_O, NULL},
	 { (char *)"InfoBlueDevice_sensorXRes_get", (PyCFunction)_wrap_InfoBlueDevice_sensorXRes_get, METH_O, NULL},
	 { (char *)"InfoBlueDevice_sensorYRes_get", (PyCFunction)_wrap_InfoBlueDevice_sensorYRes_get, METH_O, NULL},
	 { (char *)"InfoBlueDevice_sensorColorMode_get", (PyCFunction)_wrap_InfoBlueDevice_sensorColorMode_get, METH_O, NULL},
	 { (char *)"InfoBlueDevice_sensorType_get", (PyCFunction)_wrap_InfoBlueDevice_sensorType_get, METH_O, NULL},
	 { (char *)"delete_InfoBlueDevice", (PyCFunction)_wrap_delete_InfoBlueDevice, METH_O, NULL},
	 { (char *)"InfoBlueDevice_swigregister", InfoBlueDevice_swigregister, METH_VARARGS, NULL},
	 { (char *)"InfoBlueDevice_swiginit", InfoBlueDevice_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_InfoBlueCOUGAR", (PyCFunction)_wrap_new_InfoBlueCOUGAR, METH_O, NULL},
	 { (char *)"InfoBlueCOUGAR_deviceBootloaderVersion_get", (PyCFunction)_wrap_InfoBlueCOUGAR_deviceBootloaderVersion_get, METH_O, NULL},
	 { (char *)"InfoBlueCOUGAR_deviceRFSVersion_get", (PyCFunction)_wrap_InfoBlueCOUGAR_deviceRFSVersion_get, METH_O, NULL},
	 { (char *)"InfoBlueCOUGAR_deviceKernelVersion_get", (PyCFunction)_wrap_InfoBlueCOUGAR_deviceKernelVersion_get, METH_O, NULL},
	 { (char *)"InfoBlueCOUGAR_deviceFPGAVersion_get", (PyCFunction)_wrap_InfoBlueCOUGAR_deviceFPGAVersion_get, METH_O, NULL},
	 { (char *)"InfoBlueCOUGAR_deviceStatus_get", (PyCFunction)_wrap_InfoBlueCOUGAR_deviceStatus_get, METH_O, NULL},
	 { (char *)"InfoBlueCOUGAR_deviceStatusMessage_get", (PyCFunction)_wrap_InfoBlueCOUGAR_deviceStatusMessage_get, METH_O, NULL},
	 { (char *)"InfoBlueCOUGAR_deviceSensorRevision_get", (PyCFunction)_wrap_InfoBlueCOUGAR_deviceSensorRevision_get, METH_O, NULL},
	 { (char *)"InfoBlueCOUGAR_clientConnectionState_get", (PyCFunction)_wrap_InfoBlueCOUGAR_clientConnectionState_get, METH_O, NULL},
	 { (char *)"delete_InfoBlueCOUGAR", (PyCFunction)_wrap_delete_InfoBlueCOUGAR, METH_O, NULL},
	 { (char *)"InfoBlueCOUGAR_swigregister", InfoBlueCOUGAR_swigregister, METH_VARARGS, NULL},
	 { (char *)"InfoBlueCOUGAR_swiginit", InfoBlueCOUGAR_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_InfoBlueFOX", (PyCFunction)_wrap_new_InfoBlueFOX, METH_O, NULL},
	 { (char *)"InfoBlueFOX_firmwareVersion_get", (PyCFunction)_wrap_InfoBlueFOX_firmwareVersion_get, METH_O, NULL},
	 { (char *)"InfoBlueFOX_sensorFPGAVersion_get", (PyCFunction)_wrap_InfoBlueFOX_sensorFPGAVersion_get, METH_O, NULL},
	 { (char *)"InfoBlueFOX_sensorCaps_get", (PyCFunction)_wrap_InfoBlueFOX_sensorCaps_get, METH_O, NULL},
	 { (char *)"InfoBlueFOX_deviceSensorRevision_get", (PyCFunction)_wrap_InfoBlueFOX_deviceSensorRevision_get, METH_O, NULL},
	 { (char *)"InfoBlueFOX_userEEPROMSize_get", (PyCFunction)_wrap_InfoBlueFOX_userEEPROMSize_get, METH_O, NULL},
	 { (char *)"InfoBlueFOX_deviceTemperature_get", (PyCFunction)_wrap_InfoBlueFOX_deviceTemperature_get, METH_O, NULL},
	 { (char *)"delete_InfoBlueFOX", (PyCFunction)_wrap_delete_InfoBlueFOX, METH_O, NULL},
	 { (char *)"InfoBlueFOX_swigregister", InfoBlueFOX_swigregister, METH_VARARGS, NULL},
	 { (char *)"InfoBlueFOX_swiginit", InfoBlueFOX_swiginit, METH_VARARGS, NULL},
	 { (char *)"DigitalInput_get", (PyCFunction)_wrap_DigitalInput_get, METH_O, NULL},
	 { (char *)"DigitalInput_getDescription", (PyCFunction)_wrap_DigitalInput_getDescription, METH_O, NULL},
	 { (char *)"delete_DigitalInput", (PyCFunction)_wrap_delete_DigitalInput, METH_O, NULL},
	 { (char *)"DigitalInput_swigregister", DigitalInput_swigregister, METH_VARARGS, NULL},
	 { (char *)"DigitalOutput_flip", (PyCFunction)_wrap_DigitalOutput_flip, METH_O, NULL},
	 { (char *)"DigitalOutput_get", (PyCFunction)_wrap_DigitalOutput_get, METH_O, NULL},
	 { (char *)"DigitalOutput_isWriteable", (PyCFunction)_wrap_DigitalOutput_isWriteable, METH_O, NULL},
	 { (char *)"DigitalOutput_setOutput", (PyCFunction)_wrap_DigitalOutput_setOutput, METH_O, NULL},
	 { (char *)"DigitalOutput_reset", (PyCFunction)_wrap_DigitalOutput_reset, METH_O, NULL},
	 { (char *)"DigitalOutput_getDescription", (PyCFunction)_wrap_DigitalOutput_getDescription, METH_O, NULL},
	 { (char *)"delete_DigitalOutput", (PyCFunction)_wrap_delete_DigitalOutput, METH_O, NULL},
	 { (char *)"DigitalOutput_swigregister", DigitalOutput_swigregister, METH_VARARGS, NULL},
	 { (char *)"SyncOutput_frequency_Hz_get", (PyCFunction)_wrap_SyncOutput_frequency_Hz_get, METH_O, NULL},
	 { (char *)"SyncOutput_lowPart_pc_get", (PyCFunction)_wrap_SyncOutput_lowPart_pc_get, METH_O, NULL},
	 { (char *)"SyncOutput_getDescription", (PyCFunction)_wrap_SyncOutput_getDescription, METH_O, NULL},
	 { (char *)"delete_SyncOutput", (PyCFunction)_wrap_delete_SyncOutput, METH_O, NULL},
	 { (char *)"SyncOutput_swigregister", SyncOutput_swigregister, METH_VARARGS, NULL},
	 { (char *)"RTCtrProgramStep_address_get", (PyCFunction)_wrap_RTCtrProgramStep_address_get, METH_O, NULL},
	 { (char *)"RTCtrProgramStep_frameID_get", (PyCFunction)_wrap_RTCtrProgramStep_frameID_get, METH_O, NULL},
	 { (char *)"RTCtrProgramStep_clocks_us_get", (PyCFunction)_wrap_RTCtrProgramStep_clocks_us_get, METH_O, NULL},
	 { (char *)"RTCtrProgramStep_digitalInputs_get", (PyCFunction)_wrap_RTCtrProgramStep_digitalInputs_get, METH_O, NULL},
	 { (char *)"RTCtrProgramStep_digitalOutputs_get", (PyCFunction)_wrap_RTCtrProgramStep_digitalOutputs_get, METH_O, NULL},
	 { (char *)"RTCtrProgramStep_sensorHeads_get", (PyCFunction)_wrap_RTCtrProgramStep_sensorHeads_get, METH_O, NULL},
	 { (char *)"RTCtrProgramStep_opCode_get", (PyCFunction)_wrap_RTCtrProgramStep_opCode_get, METH_O, NULL},
	 { (char *)"RTCtrProgramStep_controllerRegister_get", (PyCFunction)_wrap_RTCtrProgramStep_controllerRegister_get, METH_O, NULL},
	 { (char *)"RTCtrProgramStep_registerValue_get", (PyCFunction)_wrap_RTCtrProgramStep_registerValue_get, METH_O, NULL},
	 { (char *)"delete_RTCtrProgramStep", (PyCFunction)_wrap_delete_RTCtrProgramStep, METH_O, NULL},
	 { (char *)"RTCtrProgramStep_swigregister", RTCtrProgramStep_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RTCtrProgram", (PyCFunction)_wrap_new_RTCtrProgram, METH_O, NULL},
	 { (char *)"delete_RTCtrProgram", (PyCFunction)_wrap_delete_RTCtrProgram, METH_O, NULL},
	 { (char *)"RTCtrProgram_setProgramSize", _wrap_RTCtrProgram_setProgramSize, METH_VARARGS, NULL},
	 { (char *)"RTCtrProgram_getProgramSize", (PyCFunction)_wrap_RTCtrProgram_getProgramSize, METH_O, NULL},
	 { (char *)"RTCtrProgram_programStep", _wrap_RTCtrProgram_programStep, METH_VARARGS, NULL},
	 { (char *)"RTCtrProgram_mode_get", (PyCFunction)_wrap_RTCtrProgram_mode_get, METH_O, NULL},
	 { (char *)"RTCtrProgram_filename_get", (PyCFunction)_wrap_RTCtrProgram_filename_get, METH_O, NULL},
	 { (char *)"RTCtrProgram_programState_get", (PyCFunction)_wrap_RTCtrProgram_programState_get, METH_O, NULL},
	 { (char *)"RTCtrProgram_load", (PyCFunction)_wrap_RTCtrProgram_load, METH_O, NULL},
	 { (char *)"RTCtrProgram_save", (PyCFunction)_wrap_RTCtrProgram_save, METH_O, NULL},
	 { (char *)"RTCtrProgram_swigregister", RTCtrProgram_swigregister, METH_VARARGS, NULL},
	 { (char *)"RTCtrProgram_swiginit", RTCtrProgram_swiginit, METH_VARARGS, NULL},
	 { (char *)"PulseStartConfiguration_number", (PyCFunction)_wrap_PulseStartConfiguration_number, METH_O, NULL},
	 { (char *)"PulseStartConfiguration_pulseStartTrigger_get", (PyCFunction)_wrap_PulseStartConfiguration_pulseStartTrigger_get, METH_O, NULL},
	 { (char *)"PulseStartConfiguration_digitalSignal_get", (PyCFunction)_wrap_PulseStartConfiguration_digitalSignal_get, METH_O, NULL},
	 { (char *)"PulseStartConfiguration_divider_get", (PyCFunction)_wrap_PulseStartConfiguration_divider_get, METH_O, NULL},
	 { (char *)"PulseStartConfiguration_frequency_Hz_get", (PyCFunction)_wrap_PulseStartConfiguration_frequency_Hz_get, METH_O, NULL},
	 { (char *)"PulseStartConfiguration_triggerMoment_get", (PyCFunction)_wrap_PulseStartConfiguration_triggerMoment_get, METH_O, NULL},
	 { (char *)"delete_PulseStartConfiguration", (PyCFunction)_wrap_delete_PulseStartConfiguration, METH_O, NULL},
	 { (char *)"PulseStartConfiguration_swigregister", PulseStartConfiguration_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_IOSubSystem", (PyCFunction)_wrap_delete_IOSubSystem, METH_O, NULL},
	 { (char *)"IOSubSystem_getPulseStartConfiguration", _wrap_IOSubSystem_getPulseStartConfiguration, METH_VARARGS, NULL},
	 { (char *)"IOSubSystem_getPulseStartConfigurationCount", (PyCFunction)_wrap_IOSubSystem_getPulseStartConfigurationCount, METH_O, NULL},
	 { (char *)"IOSubSystem_getRTCtrProgram", _wrap_IOSubSystem_getRTCtrProgram, METH_VARARGS, NULL},
	 { (char *)"IOSubSystem_getRTCtrProgramCount", (PyCFunction)_wrap_IOSubSystem_getRTCtrProgramCount, METH_O, NULL},
	 { (char *)"IOSubSystem_getInputCount", (PyCFunction)_wrap_IOSubSystem_getInputCount, METH_O, NULL},
	 { (char *)"IOSubSystem_readInputRegister", (PyCFunction)_wrap_IOSubSystem_readInputRegister, METH_O, NULL},
	 { (char *)"IOSubSystem_getInput", _wrap_IOSubSystem_getInput, METH_VARARGS, NULL},
	 { (char *)"IOSubSystem_getOutput", _wrap_IOSubSystem_getOutput, METH_VARARGS, NULL},
	 { (char *)"IOSubSystem_getOutputCount", (PyCFunction)_wrap_IOSubSystem_getOutputCount, METH_O, NULL},
	 { (char *)"IOSubSystem_readOutputRegister", (PyCFunction)_wrap_IOSubSystem_readOutputRegister, METH_O, NULL},
	 { (char *)"IOSubSystem_writeOutputRegister", _wrap_IOSubSystem_writeOutputRegister, METH_VARARGS, NULL},
	 { (char *)"IOSubSystem_swigregister", IOSubSystem_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_IOSubSystemBlueFOX", (PyCFunction)_wrap_new_IOSubSystemBlueFOX, METH_O, NULL},
	 { (char *)"IOSubSystemBlueFOX_readInputRegisterAtomic", (PyCFunction)_wrap_IOSubSystemBlueFOX_readInputRegisterAtomic, METH_O, NULL},
	 { (char *)"IOSubSystemBlueFOX_readOutputRegisterAtomic", (PyCFunction)_wrap_IOSubSystemBlueFOX_readOutputRegisterAtomic, METH_O, NULL},
	 { (char *)"IOSubSystemBlueFOX_writeOutputRegister", _wrap_IOSubSystemBlueFOX_writeOutputRegister, METH_VARARGS, NULL},
	 { (char *)"IOSubSystemBlueFOX_writeOutputRegisterAtomic", _wrap_IOSubSystemBlueFOX_writeOutputRegisterAtomic, METH_VARARGS, NULL},
	 { (char *)"IOSubSystemBlueFOX_digitalInputThreshold_get", (PyCFunction)_wrap_IOSubSystemBlueFOX_digitalInputThreshold_get, METH_O, NULL},
	 { (char *)"delete_IOSubSystemBlueFOX", (PyCFunction)_wrap_delete_IOSubSystemBlueFOX, METH_O, NULL},
	 { (char *)"IOSubSystemBlueFOX_swigregister", IOSubSystemBlueFOX_swigregister, METH_VARARGS, NULL},
	 { (char *)"IOSubSystemBlueFOX_swiginit", IOSubSystemBlueFOX_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_IOSubSystemCommon", (PyCFunction)_wrap_new_IOSubSystemCommon, METH_O, NULL},
	 { (char *)"IOSubSystemCommon_writeOutputRegister", _wrap_IOSubSystemCommon_writeOutputRegister, METH_VARARGS, NULL},
	 { (char *)"delete_IOSubSystemCommon", (PyCFunction)_wrap_delete_IOSubSystemCommon, METH_O, NULL},
	 { (char *)"IOSubSystemCommon_swigregister", IOSubSystemCommon_swigregister, METH_VARARGS, NULL},
	 { (char *)"IOSubSystemCommon_swiginit", IOSubSystemCommon_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_OutputSignalGeneratorBlueDevice", _wrap_new_OutputSignalGeneratorBlueDevice, METH_VARARGS, NULL},
	 { (char *)"delete_OutputSignalGeneratorBlueDevice", (PyCFunction)_wrap_delete_OutputSignalGeneratorBlueDevice, METH_O, NULL},
	 { (char *)"OutputSignalGeneratorBlueDevice_undefineSignal", _wrap_OutputSignalGeneratorBlueDevice_undefineSignal, METH_VARARGS, NULL},
	 { (char *)"OutputSignalGeneratorBlueDevice_canCreateExposeActiveSignal", _wrap_OutputSignalGeneratorBlueDevice_canCreateExposeActiveSignal, METH_VARARGS, NULL},
	 { (char *)"OutputSignalGeneratorBlueDevice_canInvertSignal", _wrap_OutputSignalGeneratorBlueDevice_canInvertSignal, METH_VARARGS, NULL},
	 { (char *)"OutputSignalGeneratorBlueDevice_getOutputMode", _wrap_OutputSignalGeneratorBlueDevice_getOutputMode, METH_VARARGS, NULL},
	 { (char *)"OutputSignalGeneratorBlueDevice_isOutputModeActive", _wrap_OutputSignalGeneratorBlueDevice_isOutputModeActive, METH_VARARGS, NULL},
	 { (char *)"OutputSignalGeneratorBlueDevice_isSignalInverted", _wrap_OutputSignalGeneratorBlueDevice_isSignalInverted, METH_VARARGS, NULL},
	 { (char *)"OutputSignalGeneratorBlueDevice_setOutputMode", _wrap_OutputSignalGeneratorBlueDevice_setOutputMode, METH_VARARGS, NULL},
	 { (char *)"OutputSignalGeneratorBlueDevice_swigregister", OutputSignalGeneratorBlueDevice_swigregister, METH_VARARGS, NULL},
	 { (char *)"OutputSignalGeneratorBlueDevice_swiginit", OutputSignalGeneratorBlueDevice_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_IOSubSystemFrameGrabber", (PyCFunction)_wrap_new_IOSubSystemFrameGrabber, METH_O, NULL},
	 { (char *)"IOSubSystemFrameGrabber_getHDOutputCount", (PyCFunction)_wrap_IOSubSystemFrameGrabber_getHDOutputCount, METH_O, NULL},
	 { (char *)"IOSubSystemFrameGrabber_HDOutput", _wrap_IOSubSystemFrameGrabber_HDOutput, METH_VARARGS, NULL},
	 { (char *)"IOSubSystemFrameGrabber_getVDOutputCount", (PyCFunction)_wrap_IOSubSystemFrameGrabber_getVDOutputCount, METH_O, NULL},
	 { (char *)"IOSubSystemFrameGrabber_VDOutput", _wrap_IOSubSystemFrameGrabber_VDOutput, METH_VARARGS, NULL},
	 { (char *)"IOSubSystemFrameGrabber_syncOutputMode_get", (PyCFunction)_wrap_IOSubSystemFrameGrabber_syncOutputMode_get, METH_O, NULL},
	 { (char *)"delete_IOSubSystemFrameGrabber", (PyCFunction)_wrap_delete_IOSubSystemFrameGrabber, METH_O, NULL},
	 { (char *)"IOSubSystemFrameGrabber_swigregister", IOSubSystemFrameGrabber_swigregister, METH_VARARGS, NULL},
	 { (char *)"IOSubSystemFrameGrabber_swiginit", IOSubSystemFrameGrabber_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_OutputSignalGeneratorFrameGrabber", _wrap_new_OutputSignalGeneratorFrameGrabber, METH_VARARGS, NULL},
	 { (char *)"delete_OutputSignalGeneratorFrameGrabber", (PyCFunction)_wrap_delete_OutputSignalGeneratorFrameGrabber, METH_O, NULL},
	 { (char *)"OutputSignalGeneratorFrameGrabber_definePulse", _wrap_OutputSignalGeneratorFrameGrabber_definePulse, METH_VARARGS, NULL},
	 { (char *)"OutputSignalGeneratorFrameGrabber_definePulseSequence", _wrap_OutputSignalGeneratorFrameGrabber_definePulseSequence, METH_VARARGS, NULL},
	 { (char *)"OutputSignalGeneratorFrameGrabber_getValidSignalsForPassThroughModes", _wrap_OutputSignalGeneratorFrameGrabber_getValidSignalsForPassThroughModes, METH_VARARGS, NULL},
	 { (char *)"OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalCount", _wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalCount, METH_VARARGS, NULL},
	 { (char *)"OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalValue", _wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalValue, METH_VARARGS, NULL},
	 { (char *)"OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalString", _wrap_OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalString, METH_VARARGS, NULL},
	 { (char *)"OutputSignalGeneratorFrameGrabber_definePassThroughSignal", _wrap_OutputSignalGeneratorFrameGrabber_definePassThroughSignal, METH_VARARGS, NULL},
	 { (char *)"OutputSignalGeneratorFrameGrabber_undefineSignal", _wrap_OutputSignalGeneratorFrameGrabber_undefineSignal, METH_VARARGS, NULL},
	 { (char *)"OutputSignalGeneratorFrameGrabber_defineLineScanPulse", _wrap_OutputSignalGeneratorFrameGrabber_defineLineScanPulse, METH_VARARGS, NULL},
	 { (char *)"OutputSignalGeneratorFrameGrabber_controlMode_get", (PyCFunction)_wrap_OutputSignalGeneratorFrameGrabber_controlMode_get, METH_O, NULL},
	 { (char *)"OutputSignalGeneratorFrameGrabber_pulseStartEvent_get", (PyCFunction)_wrap_OutputSignalGeneratorFrameGrabber_pulseStartEvent_get, METH_O, NULL},
	 { (char *)"OutputSignalGeneratorFrameGrabber_imageTrigger_get", (PyCFunction)_wrap_OutputSignalGeneratorFrameGrabber_imageTrigger_get, METH_O, NULL},
	 { (char *)"OutputSignalGeneratorFrameGrabber_swigregister", OutputSignalGeneratorFrameGrabber_swigregister, METH_VARARGS, NULL},
	 { (char *)"OutputSignalGeneratorFrameGrabber_swiginit", OutputSignalGeneratorFrameGrabber_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_IOSubSystemBlueCOUGAR", (PyCFunction)_wrap_new_IOSubSystemBlueCOUGAR, METH_O, NULL},
	 { (char *)"IOSubSystemBlueCOUGAR_digitalInputThreshold_mV_get", (PyCFunction)_wrap_IOSubSystemBlueCOUGAR_digitalInputThreshold_mV_get, METH_O, NULL},
	 { (char *)"delete_IOSubSystemBlueCOUGAR", (PyCFunction)_wrap_delete_IOSubSystemBlueCOUGAR, METH_O, NULL},
	 { (char *)"IOSubSystemBlueCOUGAR_swigregister", IOSubSystemBlueCOUGAR_swigregister, METH_VARARGS, NULL},
	 { (char *)"IOSubSystemBlueCOUGAR_swiginit", IOSubSystemBlueCOUGAR_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_Connector", _wrap_new_Connector, METH_VARARGS, NULL},
	 { (char *)"Connector_cameraOutputUsed_get", (PyCFunction)_wrap_Connector_cameraOutputUsed_get, METH_O, NULL},
	 { (char *)"Connector_videoChannel_get", (PyCFunction)_wrap_Connector_videoChannel_get, METH_O, NULL},
	 { (char *)"Connector_pinDescription_get", (PyCFunction)_wrap_Connector_pinDescription_get, METH_O, NULL},
	 { (char *)"delete_Connector", (PyCFunction)_wrap_delete_Connector, METH_O, NULL},
	 { (char *)"Connector_swigregister", Connector_swigregister, METH_VARARGS, NULL},
	 { (char *)"Connector_swiginit", Connector_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_BasicDeviceSettingsWithAOI", _wrap_new_BasicDeviceSettingsWithAOI, METH_VARARGS, NULL},
	 { (char *)"BasicDeviceSettingsWithAOI_aoiHeight_get", (PyCFunction)_wrap_BasicDeviceSettingsWithAOI_aoiHeight_get, METH_O, NULL},
	 { (char *)"BasicDeviceSettingsWithAOI_aoiStartX_get", (PyCFunction)_wrap_BasicDeviceSettingsWithAOI_aoiStartX_get, METH_O, NULL},
	 { (char *)"BasicDeviceSettingsWithAOI_aoiStartY_get", (PyCFunction)_wrap_BasicDeviceSettingsWithAOI_aoiStartY_get, METH_O, NULL},
	 { (char *)"BasicDeviceSettingsWithAOI_aoiWidth_get", (PyCFunction)_wrap_BasicDeviceSettingsWithAOI_aoiWidth_get, METH_O, NULL},
	 { (char *)"delete_BasicDeviceSettingsWithAOI", (PyCFunction)_wrap_delete_BasicDeviceSettingsWithAOI, METH_O, NULL},
	 { (char *)"BasicDeviceSettingsWithAOI_swigregister", BasicDeviceSettingsWithAOI_swigregister, METH_VARARGS, NULL},
	 { (char *)"BasicDeviceSettingsWithAOI_swiginit", BasicDeviceSettingsWithAOI_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_CameraSettingsBase", _wrap_new_CameraSettingsBase, METH_VARARGS, NULL},
	 { (char *)"CameraSettingsBase_pixelFormat_get", (PyCFunction)_wrap_CameraSettingsBase_pixelFormat_get, METH_O, NULL},
	 { (char *)"delete_CameraSettingsBase", (PyCFunction)_wrap_delete_CameraSettingsBase, METH_O, NULL},
	 { (char *)"CameraSettingsBase_swigregister", CameraSettingsBase_swigregister, METH_VARARGS, NULL},
	 { (char *)"CameraSettingsBase_swiginit", CameraSettingsBase_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_CameraSettingsVirtualDevice", _wrap_new_CameraSettingsVirtualDevice, METH_VARARGS, NULL},
	 { (char *)"CameraSettingsVirtualDevice_bufferPartCount_get", (PyCFunction)_wrap_CameraSettingsVirtualDevice_bufferPartCount_get, METH_O, NULL},
	 { (char *)"CameraSettingsVirtualDevice_aoiMode_get", (PyCFunction)_wrap_CameraSettingsVirtualDevice_aoiMode_get, METH_O, NULL},
	 { (char *)"CameraSettingsVirtualDevice_gain_dB_get", (PyCFunction)_wrap_CameraSettingsVirtualDevice_gain_dB_get, METH_O, NULL},
	 { (char *)"CameraSettingsVirtualDevice_testMode_get", (PyCFunction)_wrap_CameraSettingsVirtualDevice_testMode_get, METH_O, NULL},
	 { (char *)"CameraSettingsVirtualDevice_channelBitDepth_get", (PyCFunction)_wrap_CameraSettingsVirtualDevice_channelBitDepth_get, METH_O, NULL},
	 { (char *)"CameraSettingsVirtualDevice_paddingX_get", (PyCFunction)_wrap_CameraSettingsVirtualDevice_paddingX_get, METH_O, NULL},
	 { (char *)"CameraSettingsVirtualDevice_tapsXGeometry_get", (PyCFunction)_wrap_CameraSettingsVirtualDevice_tapsXGeometry_get, METH_O, NULL},
	 { (char *)"CameraSettingsVirtualDevice_tapsYGeometry_get", (PyCFunction)_wrap_CameraSettingsVirtualDevice_tapsYGeometry_get, METH_O, NULL},
	 { (char *)"CameraSettingsVirtualDevice_frameDelay_us_get", (PyCFunction)_wrap_CameraSettingsVirtualDevice_frameDelay_us_get, METH_O, NULL},
	 { (char *)"CameraSettingsVirtualDevice_imageDirectory_get", (PyCFunction)_wrap_CameraSettingsVirtualDevice_imageDirectory_get, METH_O, NULL},
	 { (char *)"CameraSettingsVirtualDevice_imageType_get", (PyCFunction)_wrap_CameraSettingsVirtualDevice_imageType_get, METH_O, NULL},
	 { (char *)"CameraSettingsVirtualDevice_bayerMosaicParity_get", (PyCFunction)_wrap_CameraSettingsVirtualDevice_bayerMosaicParity_get, METH_O, NULL},
	 { (char *)"CameraSettingsVirtualDevice_testImageBarWidth_get", (PyCFunction)_wrap_CameraSettingsVirtualDevice_testImageBarWidth_get, METH_O, NULL},
	 { (char *)"CameraSettingsVirtualDevice_userData_get", (PyCFunction)_wrap_CameraSettingsVirtualDevice_userData_get, METH_O, NULL},
	 { (char *)"delete_CameraSettingsVirtualDevice", (PyCFunction)_wrap_delete_CameraSettingsVirtualDevice, METH_O, NULL},
	 { (char *)"CameraSettingsVirtualDevice_swigregister", CameraSettingsVirtualDevice_swigregister, METH_VARARGS, NULL},
	 { (char *)"CameraSettingsVirtualDevice_swiginit", CameraSettingsVirtualDevice_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_CameraSettingsV4L2Device", _wrap_new_CameraSettingsV4L2Device, METH_VARARGS, NULL},
	 { (char *)"CameraSettingsV4L2Device_getCustomFeatureIterator", (PyCFunction)_wrap_CameraSettingsV4L2Device_getCustomFeatureIterator, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_imageWidth_get", (PyCFunction)_wrap_CameraSettingsV4L2Device_imageWidth_get, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_imageHeight_get", (PyCFunction)_wrap_CameraSettingsV4L2Device_imageHeight_get, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_videoStandard_get", (PyCFunction)_wrap_CameraSettingsV4L2Device_videoStandard_get, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_pixelFormat_get", (PyCFunction)_wrap_CameraSettingsV4L2Device_pixelFormat_get, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_brightness_get", (PyCFunction)_wrap_CameraSettingsV4L2Device_brightness_get, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_contrast_get", (PyCFunction)_wrap_CameraSettingsV4L2Device_contrast_get, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_saturation_get", (PyCFunction)_wrap_CameraSettingsV4L2Device_saturation_get, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_hue_get", (PyCFunction)_wrap_CameraSettingsV4L2Device_hue_get, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_blackLevel_get", (PyCFunction)_wrap_CameraSettingsV4L2Device_blackLevel_get, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_autoWhiteBalance_get", (PyCFunction)_wrap_CameraSettingsV4L2Device_autoWhiteBalance_get, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_redBalance_get", (PyCFunction)_wrap_CameraSettingsV4L2Device_redBalance_get, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_blueBalance_get", (PyCFunction)_wrap_CameraSettingsV4L2Device_blueBalance_get, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_gamma_get", (PyCFunction)_wrap_CameraSettingsV4L2Device_gamma_get, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_exposure_get", (PyCFunction)_wrap_CameraSettingsV4L2Device_exposure_get, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_autoGain_get", (PyCFunction)_wrap_CameraSettingsV4L2Device_autoGain_get, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_gain_get", (PyCFunction)_wrap_CameraSettingsV4L2Device_gain_get, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_HFlip_get", (PyCFunction)_wrap_CameraSettingsV4L2Device_HFlip_get, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_VFlip_get", (PyCFunction)_wrap_CameraSettingsV4L2Device_VFlip_get, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_powerLineFrequency_get", (PyCFunction)_wrap_CameraSettingsV4L2Device_powerLineFrequency_get, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_hueAuto_get", (PyCFunction)_wrap_CameraSettingsV4L2Device_hueAuto_get, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_whiteBalanceTemperature_get", (PyCFunction)_wrap_CameraSettingsV4L2Device_whiteBalanceTemperature_get, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_sharpness_get", (PyCFunction)_wrap_CameraSettingsV4L2Device_sharpness_get, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_backlightCompensation_get", (PyCFunction)_wrap_CameraSettingsV4L2Device_backlightCompensation_get, METH_O, NULL},
	 { (char *)"delete_CameraSettingsV4L2Device", (PyCFunction)_wrap_delete_CameraSettingsV4L2Device, METH_O, NULL},
	 { (char *)"CameraSettingsV4L2Device_swigregister", CameraSettingsV4L2Device_swigregister, METH_VARARGS, NULL},
	 { (char *)"CameraSettingsV4L2Device_swiginit", CameraSettingsV4L2Device_swiginit, METH_VARARGS, NULL},
	 { (char *)"AutoControlParameters_getIsAvailable", (PyCFunction)_wrap_AutoControlParameters_getIsAvailable, METH_O, NULL},
	 { (char *)"AutoControlParameters_aoiHeight_get", (PyCFunction)_wrap_AutoControlParameters_aoiHeight_get, METH_O, NULL},
	 { (char *)"AutoControlParameters_aoiStartX_get", (PyCFunction)_wrap_AutoControlParameters_aoiStartX_get, METH_O, NULL},
	 { (char *)"AutoControlParameters_aoiStartY_get", (PyCFunction)_wrap_AutoControlParameters_aoiStartY_get, METH_O, NULL},
	 { (char *)"AutoControlParameters_aoiWidth_get", (PyCFunction)_wrap_AutoControlParameters_aoiWidth_get, METH_O, NULL},
	 { (char *)"AutoControlParameters_aoiMode_get", (PyCFunction)_wrap_AutoControlParameters_aoiMode_get, METH_O, NULL},
	 { (char *)"AutoControlParameters_desiredAverageGreyValue_get", (PyCFunction)_wrap_AutoControlParameters_desiredAverageGreyValue_get, METH_O, NULL},
	 { (char *)"AutoControlParameters_controllerSpeed_get", (PyCFunction)_wrap_AutoControlParameters_controllerSpeed_get, METH_O, NULL},
	 { (char *)"AutoControlParameters_controllerGain_get", (PyCFunction)_wrap_AutoControlParameters_controllerGain_get, METH_O, NULL},
	 { (char *)"AutoControlParameters_controllerIntegralTime_ms_get", (PyCFunction)_wrap_AutoControlParameters_controllerIntegralTime_ms_get, METH_O, NULL},
	 { (char *)"AutoControlParameters_controllerDerivativeTime_ms_get", (PyCFunction)_wrap_AutoControlParameters_controllerDerivativeTime_ms_get, METH_O, NULL},
	 { (char *)"AutoControlParameters_controllerDelay_Images_get", (PyCFunction)_wrap_AutoControlParameters_controllerDelay_Images_get, METH_O, NULL},
	 { (char *)"AutoControlParameters_gainLowerLimit_dB_get", (PyCFunction)_wrap_AutoControlParameters_gainLowerLimit_dB_get, METH_O, NULL},
	 { (char *)"AutoControlParameters_gainUpperLimit_dB_get", (PyCFunction)_wrap_AutoControlParameters_gainUpperLimit_dB_get, METH_O, NULL},
	 { (char *)"AutoControlParameters_exposeLowerLimit_us_get", (PyCFunction)_wrap_AutoControlParameters_exposeLowerLimit_us_get, METH_O, NULL},
	 { (char *)"AutoControlParameters_exposeUpperLimit_us_get", (PyCFunction)_wrap_AutoControlParameters_exposeUpperLimit_us_get, METH_O, NULL},
	 { (char *)"delete_AutoControlParameters", (PyCFunction)_wrap_delete_AutoControlParameters, METH_O, NULL},
	 { (char *)"AutoControlParameters_swigregister", AutoControlParameters_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CameraSettingsBlueDevice", _wrap_new_CameraSettingsBlueDevice, METH_VARARGS, NULL},
	 { (char *)"CameraSettingsBlueDevice_autoControlMode_get", (PyCFunction)_wrap_CameraSettingsBlueDevice_autoControlMode_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueDevice_autoGainControl_get", (PyCFunction)_wrap_CameraSettingsBlueDevice_autoGainControl_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueDevice_autoExposeControl_get", (PyCFunction)_wrap_CameraSettingsBlueDevice_autoExposeControl_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueDevice_gain_dB_get", (PyCFunction)_wrap_CameraSettingsBlueDevice_gain_dB_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueDevice_offset_pc_get", (PyCFunction)_wrap_CameraSettingsBlueDevice_offset_pc_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueDevice_pixelClock_KHz_get", (PyCFunction)_wrap_CameraSettingsBlueDevice_pixelClock_KHz_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueDevice_exposeMode_get", (PyCFunction)_wrap_CameraSettingsBlueDevice_exposeMode_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueDevice_expose_us_get", (PyCFunction)_wrap_CameraSettingsBlueDevice_expose_us_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueDevice_binningMode_get", (PyCFunction)_wrap_CameraSettingsBlueDevice_binningMode_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueDevice_testMode_get", (PyCFunction)_wrap_CameraSettingsBlueDevice_testMode_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueDevice_triggerMode_get", (PyCFunction)_wrap_CameraSettingsBlueDevice_triggerMode_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueDevice_frameDelay_us_get", (PyCFunction)_wrap_CameraSettingsBlueDevice_frameDelay_us_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueDevice_autoControlParameters_get", (PyCFunction)_wrap_CameraSettingsBlueDevice_autoControlParameters_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueDevice_getAutoControlParameters", (PyCFunction)_wrap_CameraSettingsBlueDevice_getAutoControlParameters, METH_O, NULL},
	 { (char *)"delete_CameraSettingsBlueDevice", (PyCFunction)_wrap_delete_CameraSettingsBlueDevice, METH_O, NULL},
	 { (char *)"CameraSettingsBlueDevice_swigregister", CameraSettingsBlueDevice_swigregister, METH_VARARGS, NULL},
	 { (char *)"CameraSettingsBlueDevice_swiginit", CameraSettingsBlueDevice_swiginit, METH_VARARGS, NULL},
	 { (char *)"HDRKneePoint_HDRControlVoltage_mV_get", (PyCFunction)_wrap_HDRKneePoint_HDRControlVoltage_mV_get, METH_O, NULL},
	 { (char *)"HDRKneePoint_HDRExposure_ppm_get", (PyCFunction)_wrap_HDRKneePoint_HDRExposure_ppm_get, METH_O, NULL},
	 { (char *)"delete_HDRKneePoint", (PyCFunction)_wrap_delete_HDRKneePoint, METH_O, NULL},
	 { (char *)"HDRKneePoint_swigregister", HDRKneePoint_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HDRControl", (PyCFunction)_wrap_new_HDRControl, METH_O, NULL},
	 { (char *)"delete_HDRControl", (PyCFunction)_wrap_delete_HDRControl, METH_O, NULL},
	 { (char *)"HDRControl_getIsAvailable", (PyCFunction)_wrap_HDRControl_getIsAvailable, METH_O, NULL},
	 { (char *)"HDRControl_getHDRKneePoint", _wrap_HDRControl_getHDRKneePoint, METH_VARARGS, NULL},
	 { (char *)"HDRControl_HDREnable_get", (PyCFunction)_wrap_HDRControl_HDREnable_get, METH_O, NULL},
	 { (char *)"HDRControl_HDRMode_get", (PyCFunction)_wrap_HDRControl_HDRMode_get, METH_O, NULL},
	 { (char *)"HDRControl_HDRKneePointCount_get", (PyCFunction)_wrap_HDRControl_HDRKneePointCount_get, METH_O, NULL},
	 { (char *)"HDRControl_swigregister", HDRControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"HDRControl_swiginit", HDRControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_CameraSettingsBlueFOX", _wrap_new_CameraSettingsBlueFOX, METH_VARARGS, NULL},
	 { (char *)"CameraSettingsBlueFOX_getHDRControl", (PyCFunction)_wrap_CameraSettingsBlueFOX_getHDRControl, METH_O, NULL},
	 { (char *)"CameraSettingsBlueFOX_offsetAutoCalibration_get", (PyCFunction)_wrap_CameraSettingsBlueFOX_offsetAutoCalibration_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueFOX_offsetCorrection_pc_get", (PyCFunction)_wrap_CameraSettingsBlueFOX_offsetCorrection_pc_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueFOX_offsetAutoBlackLevel_get", (PyCFunction)_wrap_CameraSettingsBlueFOX_offsetAutoBlackLevel_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueFOX_offsetAutoBlackSpeed_get", (PyCFunction)_wrap_CameraSettingsBlueFOX_offsetAutoBlackSpeed_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueFOX_lineDelay_clk_get", (PyCFunction)_wrap_CameraSettingsBlueFOX_lineDelay_clk_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueFOX_advancedOptions_get", (PyCFunction)_wrap_CameraSettingsBlueFOX_advancedOptions_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueFOX_flashToExposeDelay_us_get", (PyCFunction)_wrap_CameraSettingsBlueFOX_flashToExposeDelay_us_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueFOX_flashMode_get", (PyCFunction)_wrap_CameraSettingsBlueFOX_flashMode_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueFOX_flashType_get", (PyCFunction)_wrap_CameraSettingsBlueFOX_flashType_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueFOX_shutterMode_get", (PyCFunction)_wrap_CameraSettingsBlueFOX_shutterMode_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueFOX_triggerSource_get", (PyCFunction)_wrap_CameraSettingsBlueFOX_triggerSource_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueFOX_sensorTimingMode_get", (PyCFunction)_wrap_CameraSettingsBlueFOX_sensorTimingMode_get, METH_O, NULL},
	 { (char *)"delete_CameraSettingsBlueFOX", (PyCFunction)_wrap_delete_CameraSettingsBlueFOX, METH_O, NULL},
	 { (char *)"CameraSettingsBlueFOX_swigregister", CameraSettingsBlueFOX_swigregister, METH_VARARGS, NULL},
	 { (char *)"CameraSettingsBlueFOX_swiginit", CameraSettingsBlueFOX_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_CameraSettingsBlueCOUGAR", _wrap_new_CameraSettingsBlueCOUGAR, METH_VARARGS, NULL},
	 { (char *)"delete_CameraSettingsBlueCOUGAR", (PyCFunction)_wrap_delete_CameraSettingsBlueCOUGAR, METH_O, NULL},
	 { (char *)"CameraSettingsBlueCOUGAR_getTriggerControlCount", (PyCFunction)_wrap_CameraSettingsBlueCOUGAR_getTriggerControlCount, METH_O, NULL},
	 { (char *)"CameraSettingsBlueCOUGAR_triggerControl", _wrap_CameraSettingsBlueCOUGAR_triggerControl, METH_VARARGS, NULL},
	 { (char *)"CameraSettingsBlueCOUGAR_getHDRControl", (PyCFunction)_wrap_CameraSettingsBlueCOUGAR_getHDRControl, METH_O, NULL},
	 { (char *)"CameraSettingsBlueCOUGAR_frameRate_Hz_get", (PyCFunction)_wrap_CameraSettingsBlueCOUGAR_frameRate_Hz_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueCOUGAR_partialScanMode_get", (PyCFunction)_wrap_CameraSettingsBlueCOUGAR_partialScanMode_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueCOUGAR_triggerInterface_get", (PyCFunction)_wrap_CameraSettingsBlueCOUGAR_triggerInterface_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueCOUGAR_triggerSource_get", (PyCFunction)_wrap_CameraSettingsBlueCOUGAR_triggerSource_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueCOUGAR_acquisitionBurstFrameCount_get", (PyCFunction)_wrap_CameraSettingsBlueCOUGAR_acquisitionBurstFrameCount_get, METH_O, NULL},
	 { (char *)"CameraSettingsBlueCOUGAR_swigregister", CameraSettingsBlueCOUGAR_swigregister, METH_VARARGS, NULL},
	 { (char *)"CameraSettingsBlueCOUGAR_swiginit", CameraSettingsBlueCOUGAR_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_CameraSettingsFrameGrabber", _wrap_new_CameraSettingsFrameGrabber, METH_VARARGS, NULL},
	 { (char *)"delete_CameraSettingsFrameGrabber", (PyCFunction)_wrap_delete_CameraSettingsFrameGrabber, METH_O, NULL},
	 { (char *)"CameraSettingsFrameGrabber_getTriggerControlCount", (PyCFunction)_wrap_CameraSettingsFrameGrabber_getTriggerControlCount, METH_O, NULL},
	 { (char *)"CameraSettingsFrameGrabber_triggerControl", _wrap_CameraSettingsFrameGrabber_triggerControl, METH_VARARGS, NULL},
	 { (char *)"CameraSettingsFrameGrabber_type_get", (PyCFunction)_wrap_CameraSettingsFrameGrabber_type_get, METH_O, NULL},
	 { (char *)"CameraSettingsFrameGrabber_aoiMode_get", (PyCFunction)_wrap_CameraSettingsFrameGrabber_aoiMode_get, METH_O, NULL},
	 { (char *)"CameraSettingsFrameGrabber_gain_dB_get", (PyCFunction)_wrap_CameraSettingsFrameGrabber_gain_dB_get, METH_O, NULL},
	 { (char *)"CameraSettingsFrameGrabber_offset_mV_get", (PyCFunction)_wrap_CameraSettingsFrameGrabber_offset_mV_get, METH_O, NULL},
	 { (char *)"CameraSettingsFrameGrabber_scanClock_get", (PyCFunction)_wrap_CameraSettingsFrameGrabber_scanClock_get, METH_O, NULL},
	 { (char *)"CameraSettingsFrameGrabber_triggerMode_get", (PyCFunction)_wrap_CameraSettingsFrameGrabber_triggerMode_get, METH_O, NULL},
	 { (char *)"CameraSettingsFrameGrabber_softwareTriggerPeriod_ms_get", (PyCFunction)_wrap_CameraSettingsFrameGrabber_softwareTriggerPeriod_ms_get, METH_O, NULL},
	 { (char *)"CameraSettingsFrameGrabber_serialPortBaudrate_get", (PyCFunction)_wrap_CameraSettingsFrameGrabber_serialPortBaudrate_get, METH_O, NULL},
	 { (char *)"CameraSettingsFrameGrabber_interlacedMode_get", (PyCFunction)_wrap_CameraSettingsFrameGrabber_interlacedMode_get, METH_O, NULL},
	 { (char *)"CameraSettingsFrameGrabber_acquisitionField_get", (PyCFunction)_wrap_CameraSettingsFrameGrabber_acquisitionField_get, METH_O, NULL},
	 { (char *)"CameraSettingsFrameGrabber_scanRateMode_get", (PyCFunction)_wrap_CameraSettingsFrameGrabber_scanRateMode_get, METH_O, NULL},
	 { (char *)"CameraSettingsFrameGrabber_scanRate_kHz_get", (PyCFunction)_wrap_CameraSettingsFrameGrabber_scanRate_kHz_get, METH_O, NULL},
	 { (char *)"CameraSettingsFrameGrabber_luminance_pc_get", (PyCFunction)_wrap_CameraSettingsFrameGrabber_luminance_pc_get, METH_O, NULL},
	 { (char *)"CameraSettingsFrameGrabber_saturation_pc_get", (PyCFunction)_wrap_CameraSettingsFrameGrabber_saturation_pc_get, METH_O, NULL},
	 { (char *)"CameraSettingsFrameGrabber_hue_pc_get", (PyCFunction)_wrap_CameraSettingsFrameGrabber_hue_pc_get, METH_O, NULL},
	 { (char *)"CameraSettingsFrameGrabber_contrast_pc_get", (PyCFunction)_wrap_CameraSettingsFrameGrabber_contrast_pc_get, METH_O, NULL},
	 { (char *)"CameraSettingsFrameGrabber_lineCounter_get", (PyCFunction)_wrap_CameraSettingsFrameGrabber_lineCounter_get, METH_O, NULL},
	 { (char *)"CameraSettingsFrameGrabber_swigregister", CameraSettingsFrameGrabber_swigregister, METH_VARARGS, NULL},
	 { (char *)"CameraSettingsFrameGrabber_swiginit", CameraSettingsFrameGrabber_swiginit, METH_VARARGS, NULL},
	 { (char *)"CameraDescriptionBase_getClassName", (PyCFunction)_wrap_CameraDescriptionBase_getClassName, METH_O, NULL},
	 { (char *)"CameraDescriptionBase_copyDescription", _wrap_CameraDescriptionBase_copyDescription, METH_VARARGS, NULL},
	 { (char *)"CameraDescriptionBase_exportDescription", (PyCFunction)_wrap_CameraDescriptionBase_exportDescription, METH_O, NULL},
	 { (char *)"CameraDescriptionBase_importDescription", (PyCFunction)_wrap_CameraDescriptionBase_importDescription, METH_O, NULL},
	 { (char *)"CameraDescriptionBase_name_get", (PyCFunction)_wrap_CameraDescriptionBase_name_get, METH_O, NULL},
	 { (char *)"CameraDescriptionBase_videoOutput_get", (PyCFunction)_wrap_CameraDescriptionBase_videoOutput_get, METH_O, NULL},
	 { (char *)"CameraDescriptionBase_interlacedType_get", (PyCFunction)_wrap_CameraDescriptionBase_interlacedType_get, METH_O, NULL},
	 { (char *)"CameraDescriptionBase_aoiHeight_get", (PyCFunction)_wrap_CameraDescriptionBase_aoiHeight_get, METH_O, NULL},
	 { (char *)"CameraDescriptionBase_aoiStartX_get", (PyCFunction)_wrap_CameraDescriptionBase_aoiStartX_get, METH_O, NULL},
	 { (char *)"CameraDescriptionBase_aoiStartY_get", (PyCFunction)_wrap_CameraDescriptionBase_aoiStartY_get, METH_O, NULL},
	 { (char *)"CameraDescriptionBase_aoiWidth_get", (PyCFunction)_wrap_CameraDescriptionBase_aoiWidth_get, METH_O, NULL},
	 { (char *)"delete_CameraDescriptionBase", (PyCFunction)_wrap_delete_CameraDescriptionBase, METH_O, NULL},
	 { (char *)"CameraDescriptionBase_swigregister", CameraDescriptionBase_swigregister, METH_VARARGS, NULL},
	 { (char *)"CameraDescriptionDigitalBase_bitsPerPixel_get", (PyCFunction)_wrap_CameraDescriptionDigitalBase_bitsPerPixel_get, METH_O, NULL},
	 { (char *)"CameraDescriptionDigitalBase_format_get", (PyCFunction)_wrap_CameraDescriptionDigitalBase_format_get, METH_O, NULL},
	 { (char *)"CameraDescriptionDigitalBase_bayerParity_get", (PyCFunction)_wrap_CameraDescriptionDigitalBase_bayerParity_get, METH_O, NULL},
	 { (char *)"delete_CameraDescriptionDigitalBase", (PyCFunction)_wrap_delete_CameraDescriptionDigitalBase, METH_O, NULL},
	 { (char *)"CameraDescriptionDigitalBase_swigregister", CameraDescriptionDigitalBase_swigregister, METH_VARARGS, NULL},
	 { (char *)"CameraDescriptionSDI_videoStandard_get", (PyCFunction)_wrap_CameraDescriptionSDI_videoStandard_get, METH_O, NULL},
	 { (char *)"delete_CameraDescriptionSDI", (PyCFunction)_wrap_delete_CameraDescriptionSDI, METH_O, NULL},
	 { (char *)"CameraDescriptionSDI_swigregister", CameraDescriptionSDI_swigregister, METH_VARARGS, NULL},
	 { (char *)"CameraDescriptionDigitalBase2_pixelsPerCycle_get", (PyCFunction)_wrap_CameraDescriptionDigitalBase2_pixelsPerCycle_get, METH_O, NULL},
	 { (char *)"CameraDescriptionDigitalBase2_scanMode_get", (PyCFunction)_wrap_CameraDescriptionDigitalBase2_scanMode_get, METH_O, NULL},
	 { (char *)"delete_CameraDescriptionDigitalBase2", (PyCFunction)_wrap_delete_CameraDescriptionDigitalBase2, METH_O, NULL},
	 { (char *)"CameraDescriptionDigitalBase2_swigregister", CameraDescriptionDigitalBase2_swigregister, METH_VARARGS, NULL},
	 { (char *)"CameraDescriptionCameraLink_dataValid_get", (PyCFunction)_wrap_CameraDescriptionCameraLink_dataValid_get, METH_O, NULL},
	 { (char *)"CameraDescriptionCameraLink_tapsXGeometry_get", (PyCFunction)_wrap_CameraDescriptionCameraLink_tapsXGeometry_get, METH_O, NULL},
	 { (char *)"CameraDescriptionCameraLink_tapsYGeometry_get", (PyCFunction)_wrap_CameraDescriptionCameraLink_tapsYGeometry_get, METH_O, NULL},
	 { (char *)"delete_CameraDescriptionCameraLink", (PyCFunction)_wrap_delete_CameraDescriptionCameraLink, METH_O, NULL},
	 { (char *)"CameraDescriptionCameraLink_swigregister", CameraDescriptionCameraLink_swigregister, METH_VARARGS, NULL},
	 { (char *)"CameraDescriptionDigital_frameSync_get", (PyCFunction)_wrap_CameraDescriptionDigital_frameSync_get, METH_O, NULL},
	 { (char *)"CameraDescriptionDigital_lineSync_get", (PyCFunction)_wrap_CameraDescriptionDigital_lineSync_get, METH_O, NULL},
	 { (char *)"CameraDescriptionDigital_pixelClk_get", (PyCFunction)_wrap_CameraDescriptionDigital_pixelClk_get, METH_O, NULL},
	 { (char *)"delete_CameraDescriptionDigital", (PyCFunction)_wrap_delete_CameraDescriptionDigital, METH_O, NULL},
	 { (char *)"CameraDescriptionDigital_swigregister", CameraDescriptionDigital_swigregister, METH_VARARGS, NULL},
	 { (char *)"CameraDescriptionStandardBase_videoStandard_get", (PyCFunction)_wrap_CameraDescriptionStandardBase_videoStandard_get, METH_O, NULL},
	 { (char *)"CameraDescriptionStandardBase_scanStandard_get", (PyCFunction)_wrap_CameraDescriptionStandardBase_scanStandard_get, METH_O, NULL},
	 { (char *)"CameraDescriptionStandardBase_scanRate_kHz_get", (PyCFunction)_wrap_CameraDescriptionStandardBase_scanRate_kHz_get, METH_O, NULL},
	 { (char *)"CameraDescriptionStandardBase_startField_get", (PyCFunction)_wrap_CameraDescriptionStandardBase_startField_get, METH_O, NULL},
	 { (char *)"delete_CameraDescriptionStandardBase", (PyCFunction)_wrap_delete_CameraDescriptionStandardBase, METH_O, NULL},
	 { (char *)"CameraDescriptionStandardBase_swigregister", CameraDescriptionStandardBase_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_CameraDescriptionStandard", (PyCFunction)_wrap_delete_CameraDescriptionStandard, METH_O, NULL},
	 { (char *)"CameraDescriptionStandard_swigregister", CameraDescriptionStandard_swigregister, METH_VARARGS, NULL},
	 { (char *)"CameraDescriptionNonStandard_lineFrequency_Hz_get", (PyCFunction)_wrap_CameraDescriptionNonStandard_lineFrequency_Hz_get, METH_O, NULL},
	 { (char *)"CameraDescriptionNonStandard_VDOutput_get", (PyCFunction)_wrap_CameraDescriptionNonStandard_VDOutput_get, METH_O, NULL},
	 { (char *)"CameraDescriptionNonStandard_HDOutput_get", (PyCFunction)_wrap_CameraDescriptionNonStandard_HDOutput_get, METH_O, NULL},
	 { (char *)"CameraDescriptionNonStandard_syncOutput_get", (PyCFunction)_wrap_CameraDescriptionNonStandard_syncOutput_get, METH_O, NULL},
	 { (char *)"CameraDescriptionNonStandard_pixelClockOutput_get", (PyCFunction)_wrap_CameraDescriptionNonStandard_pixelClockOutput_get, METH_O, NULL},
	 { (char *)"CameraDescriptionNonStandard_fieldGateMode_get", (PyCFunction)_wrap_CameraDescriptionNonStandard_fieldGateMode_get, METH_O, NULL},
	 { (char *)"CameraDescriptionNonStandard_fieldGateStart_get", (PyCFunction)_wrap_CameraDescriptionNonStandard_fieldGateStart_get, METH_O, NULL},
	 { (char *)"CameraDescriptionNonStandard_fieldGateWidth_get", (PyCFunction)_wrap_CameraDescriptionNonStandard_fieldGateWidth_get, METH_O, NULL},
	 { (char *)"CameraDescriptionNonStandard_clampMode_get", (PyCFunction)_wrap_CameraDescriptionNonStandard_clampMode_get, METH_O, NULL},
	 { (char *)"CameraDescriptionNonStandard_clampStart_us_get", (PyCFunction)_wrap_CameraDescriptionNonStandard_clampStart_us_get, METH_O, NULL},
	 { (char *)"delete_CameraDescriptionNonStandard", (PyCFunction)_wrap_delete_CameraDescriptionNonStandard, METH_O, NULL},
	 { (char *)"CameraDescriptionNonStandard_swigregister", CameraDescriptionNonStandard_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CameraDescriptionManager", _wrap_new_CameraDescriptionManager, METH_VARARGS, NULL},
	 { (char *)"delete_CameraDescriptionManager", (PyCFunction)_wrap_delete_CameraDescriptionManager, METH_O, NULL},
	 { (char *)"CameraDescriptionManager_getCLCameraDescriptionCount", (PyCFunction)_wrap_CameraDescriptionManager_getCLCameraDescriptionCount, METH_O, NULL},
	 { (char *)"CameraDescriptionManager_cameraDescriptionCameraLink", _wrap_CameraDescriptionManager_cameraDescriptionCameraLink, METH_VARARGS, NULL},
	 { (char *)"CameraDescriptionManager_getSDICameraDescriptionCount", (PyCFunction)_wrap_CameraDescriptionManager_getSDICameraDescriptionCount, METH_O, NULL},
	 { (char *)"CameraDescriptionManager_cameraDescriptionSDI", _wrap_CameraDescriptionManager_cameraDescriptionSDI, METH_VARARGS, NULL},
	 { (char *)"CameraDescriptionManager_getDigitalCameraDescriptionCount", (PyCFunction)_wrap_CameraDescriptionManager_getDigitalCameraDescriptionCount, METH_O, NULL},
	 { (char *)"CameraDescriptionManager_cameraDescriptionDigital", _wrap_CameraDescriptionManager_cameraDescriptionDigital, METH_VARARGS, NULL},
	 { (char *)"CameraDescriptionManager_getStandardCameraDescriptionCount", (PyCFunction)_wrap_CameraDescriptionManager_getStandardCameraDescriptionCount, METH_O, NULL},
	 { (char *)"CameraDescriptionManager_cameraDescriptionStandard", _wrap_CameraDescriptionManager_cameraDescriptionStandard, METH_VARARGS, NULL},
	 { (char *)"CameraDescriptionManager_getNonStandardCameraDescriptionCount", (PyCFunction)_wrap_CameraDescriptionManager_getNonStandardCameraDescriptionCount, METH_O, NULL},
	 { (char *)"CameraDescriptionManager_cameraDescriptionNonStandard", _wrap_CameraDescriptionManager_cameraDescriptionNonStandard, METH_VARARGS, NULL},
	 { (char *)"CameraDescriptionManager_getTotalCameraDescriptionCount", (PyCFunction)_wrap_CameraDescriptionManager_getTotalCameraDescriptionCount, METH_O, NULL},
	 { (char *)"CameraDescriptionManager_swigregister", CameraDescriptionManager_swigregister, METH_VARARGS, NULL},
	 { (char *)"CameraDescriptionManager_swiginit", CameraDescriptionManager_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_I2CControl", (PyCFunction)_wrap_new_I2CControl, METH_O, NULL},
	 { (char *)"I2CControl_I2COperationMode_get", (PyCFunction)_wrap_I2CControl_I2COperationMode_get, METH_O, NULL},
	 { (char *)"I2CControl_I2COperationExecute_get", (PyCFunction)_wrap_I2CControl_I2COperationExecute_get, METH_O, NULL},
	 { (char *)"I2CControl_I2COperationStatus_get", (PyCFunction)_wrap_I2CControl_I2COperationStatus_get, METH_O, NULL},
	 { (char *)"I2CControl_I2CDeviceAddress_get", (PyCFunction)_wrap_I2CControl_I2CDeviceAddress_get, METH_O, NULL},
	 { (char *)"I2CControl_I2CDeviceSubAddressWidth_get", (PyCFunction)_wrap_I2CControl_I2CDeviceSubAddressWidth_get, METH_O, NULL},
	 { (char *)"I2CControl_I2CDeviceSubAddress_get", (PyCFunction)_wrap_I2CControl_I2CDeviceSubAddress_get, METH_O, NULL},
	 { (char *)"I2CControl_I2CBuffer_get", (PyCFunction)_wrap_I2CControl_I2CBuffer_get, METH_O, NULL},
	 { (char *)"I2CControl_I2CBufferLength_get", (PyCFunction)_wrap_I2CControl_I2CBufferLength_get, METH_O, NULL},
	 { (char *)"I2CControl_I2CRead", _wrap_I2CControl_I2CRead, METH_VARARGS, NULL},
	 { (char *)"I2CControl_I2CWrite", _wrap_I2CControl_I2CWrite, METH_VARARGS, NULL},
	 { (char *)"delete_I2CControl", (PyCFunction)_wrap_delete_I2CControl, METH_O, NULL},
	 { (char *)"I2CControl_swigregister", I2CControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"I2CControl_swiginit", I2CControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_MotorFocusControl", (PyCFunction)_wrap_new_MotorFocusControl, METH_O, NULL},
	 { (char *)"MotorFocusControl_motorFocusSendBuffer_get", (PyCFunction)_wrap_MotorFocusControl_motorFocusSendBuffer_get, METH_O, NULL},
	 { (char *)"MotorFocusControl_motorFocusReceiveBuffer_get", (PyCFunction)_wrap_MotorFocusControl_motorFocusReceiveBuffer_get, METH_O, NULL},
	 { (char *)"MotorFocusControl_motorFocusSend_get", (PyCFunction)_wrap_MotorFocusControl_motorFocusSend_get, METH_O, NULL},
	 { (char *)"MotorFocusControl_motorFocusIncrement_get", (PyCFunction)_wrap_MotorFocusControl_motorFocusIncrement_get, METH_O, NULL},
	 { (char *)"MotorFocusControl_motorFocusNear_get", (PyCFunction)_wrap_MotorFocusControl_motorFocusNear_get, METH_O, NULL},
	 { (char *)"MotorFocusControl_motorFocusFar_get", (PyCFunction)_wrap_MotorFocusControl_motorFocusFar_get, METH_O, NULL},
	 { (char *)"MotorFocusControl_motorFocusAbsolutePositionCurrent_get", (PyCFunction)_wrap_MotorFocusControl_motorFocusAbsolutePositionCurrent_get, METH_O, NULL},
	 { (char *)"MotorFocusControl_motorFocusAbsolutePositionDesired_get", (PyCFunction)_wrap_MotorFocusControl_motorFocusAbsolutePositionDesired_get, METH_O, NULL},
	 { (char *)"MotorFocusControl_motorFocusMoveToAbsolutePositionDesired_get", (PyCFunction)_wrap_MotorFocusControl_motorFocusMoveToAbsolutePositionDesired_get, METH_O, NULL},
	 { (char *)"delete_MotorFocusControl", (PyCFunction)_wrap_delete_MotorFocusControl, METH_O, NULL},
	 { (char *)"MotorFocusControl_swigregister", MotorFocusControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"MotorFocusControl_swiginit", MotorFocusControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_DigitalIOMeasurementControl", (PyCFunction)_wrap_new_DigitalIOMeasurementControl, METH_O, NULL},
	 { (char *)"DigitalIOMeasurementControl_digitalIOMeasurementMode_get", (PyCFunction)_wrap_DigitalIOMeasurementControl_digitalIOMeasurementMode_get, METH_O, NULL},
	 { (char *)"DigitalIOMeasurementControl_digitalIOMeasurementSource_get", (PyCFunction)_wrap_DigitalIOMeasurementControl_digitalIOMeasurementSource_get, METH_O, NULL},
	 { (char *)"DigitalIOMeasurementControl_digitalIOMeasurementResult_get", (PyCFunction)_wrap_DigitalIOMeasurementControl_digitalIOMeasurementResult_get, METH_O, NULL},
	 { (char *)"delete_DigitalIOMeasurementControl", (PyCFunction)_wrap_delete_DigitalIOMeasurementControl, METH_O, NULL},
	 { (char *)"DigitalIOMeasurementControl_swigregister", DigitalIOMeasurementControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"DigitalIOMeasurementControl_swiginit", DigitalIOMeasurementControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_SettingsBlueFOX", _wrap_new_SettingsBlueFOX, METH_VARARGS, NULL},
	 { (char *)"SettingsBlueFOX_cameraSetting_get", (PyCFunction)_wrap_SettingsBlueFOX_cameraSetting_get, METH_O, NULL},
	 { (char *)"delete_SettingsBlueFOX", (PyCFunction)_wrap_delete_SettingsBlueFOX, METH_O, NULL},
	 { (char *)"SettingsBlueFOX_swigregister", SettingsBlueFOX_swigregister, METH_VARARGS, NULL},
	 { (char *)"SettingsBlueFOX_swiginit", SettingsBlueFOX_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_SettingsFrameGrabber", _wrap_new_SettingsFrameGrabber, METH_VARARGS, NULL},
	 { (char *)"SettingsFrameGrabber_cameraSetting_get", (PyCFunction)_wrap_SettingsFrameGrabber_cameraSetting_get, METH_O, NULL},
	 { (char *)"SettingsFrameGrabber_connector_get", (PyCFunction)_wrap_SettingsFrameGrabber_connector_get, METH_O, NULL},
	 { (char *)"delete_SettingsFrameGrabber", (PyCFunction)_wrap_delete_SettingsFrameGrabber, METH_O, NULL},
	 { (char *)"SettingsFrameGrabber_swigregister", SettingsFrameGrabber_swigregister, METH_VARARGS, NULL},
	 { (char *)"SettingsFrameGrabber_swiginit", SettingsFrameGrabber_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_SystemBlueFOX", (PyCFunction)_wrap_new_SystemBlueFOX, METH_O, NULL},
	 { (char *)"SystemBlueFOX_transferSize_get", (PyCFunction)_wrap_SystemBlueFOX_transferSize_get, METH_O, NULL},
	 { (char *)"SystemBlueFOX_footerMode_get", (PyCFunction)_wrap_SystemBlueFOX_footerMode_get, METH_O, NULL},
	 { (char *)"SystemBlueFOX_footerCheckEnable_get", (PyCFunction)_wrap_SystemBlueFOX_footerCheckEnable_get, METH_O, NULL},
	 { (char *)"SystemBlueFOX_powerMode_get", (PyCFunction)_wrap_SystemBlueFOX_powerMode_get, METH_O, NULL},
	 { (char *)"SystemBlueFOX_statusLEDEnable_get", (PyCFunction)_wrap_SystemBlueFOX_statusLEDEnable_get, METH_O, NULL},
	 { (char *)"delete_SystemBlueFOX", (PyCFunction)_wrap_delete_SystemBlueFOX, METH_O, NULL},
	 { (char *)"SystemBlueFOX_swigregister", SystemBlueFOX_swigregister, METH_VARARGS, NULL},
	 { (char *)"SystemBlueFOX_swiginit", SystemBlueFOX_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_SystemV4L2", (PyCFunction)_wrap_new_SystemV4L2, METH_O, NULL},
	 { (char *)"SystemV4L2_volume_get", (PyCFunction)_wrap_SystemV4L2_volume_get, METH_O, NULL},
	 { (char *)"SystemV4L2_balance_get", (PyCFunction)_wrap_SystemV4L2_balance_get, METH_O, NULL},
	 { (char *)"SystemV4L2_bass_get", (PyCFunction)_wrap_SystemV4L2_bass_get, METH_O, NULL},
	 { (char *)"SystemV4L2_treble_get", (PyCFunction)_wrap_SystemV4L2_treble_get, METH_O, NULL},
	 { (char *)"SystemV4L2_mute_get", (PyCFunction)_wrap_SystemV4L2_mute_get, METH_O, NULL},
	 { (char *)"SystemV4L2_loudness_get", (PyCFunction)_wrap_SystemV4L2_loudness_get, METH_O, NULL},
	 { (char *)"delete_SystemV4L2", (PyCFunction)_wrap_delete_SystemV4L2, METH_O, NULL},
	 { (char *)"SystemV4L2_swigregister", SystemV4L2_swigregister, METH_VARARGS, NULL},
	 { (char *)"SystemV4L2_swiginit", SystemV4L2_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_DeviceControl", _wrap_new_DeviceControl, METH_VARARGS, NULL},
	 { (char *)"DeviceControl_deviceType_get", (PyCFunction)_wrap_DeviceControl_deviceType_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceScanType_get", (PyCFunction)_wrap_DeviceControl_deviceScanType_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceVendorName_get", (PyCFunction)_wrap_DeviceControl_deviceVendorName_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceModelName_get", (PyCFunction)_wrap_DeviceControl_deviceModelName_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceFamilyName_get", (PyCFunction)_wrap_DeviceControl_deviceFamilyName_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceManufacturerInfo_get", (PyCFunction)_wrap_DeviceControl_deviceManufacturerInfo_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceVersion_get", (PyCFunction)_wrap_DeviceControl_deviceVersion_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceFirmwareVersion_get", (PyCFunction)_wrap_DeviceControl_deviceFirmwareVersion_get, METH_O, NULL},
	 { (char *)"DeviceControl_mvDeviceFirmwareBuildDate_get", (PyCFunction)_wrap_DeviceControl_mvDeviceFirmwareBuildDate_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceSerialNumber_get", (PyCFunction)_wrap_DeviceControl_deviceSerialNumber_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceID_get", (PyCFunction)_wrap_DeviceControl_deviceID_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceUserID_get", (PyCFunction)_wrap_DeviceControl_deviceUserID_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceSFNCVersionMajor_get", (PyCFunction)_wrap_DeviceControl_deviceSFNCVersionMajor_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceSFNCVersionMinor_get", (PyCFunction)_wrap_DeviceControl_deviceSFNCVersionMinor_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceSFNCVersionSubMinor_get", (PyCFunction)_wrap_DeviceControl_deviceSFNCVersionSubMinor_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceManifestEntrySelector_get", (PyCFunction)_wrap_DeviceControl_deviceManifestEntrySelector_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceManifestXMLMajorVersion_get", (PyCFunction)_wrap_DeviceControl_deviceManifestXMLMajorVersion_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceManifestXMLMinorVersion_get", (PyCFunction)_wrap_DeviceControl_deviceManifestXMLMinorVersion_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceManifestXMLSubMinorVersion_get", (PyCFunction)_wrap_DeviceControl_deviceManifestXMLSubMinorVersion_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceManifestSchemaMajorVersion_get", (PyCFunction)_wrap_DeviceControl_deviceManifestSchemaMajorVersion_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceManifestSchemaMinorVersion_get", (PyCFunction)_wrap_DeviceControl_deviceManifestSchemaMinorVersion_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceManifestPrimaryURL_get", (PyCFunction)_wrap_DeviceControl_deviceManifestPrimaryURL_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceManifestSecondaryURL_get", (PyCFunction)_wrap_DeviceControl_deviceManifestSecondaryURL_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceTLType_get", (PyCFunction)_wrap_DeviceControl_deviceTLType_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceTLVersionMajor_get", (PyCFunction)_wrap_DeviceControl_deviceTLVersionMajor_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceTLVersionMinor_get", (PyCFunction)_wrap_DeviceControl_deviceTLVersionMinor_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceTLVersionSubMinor_get", (PyCFunction)_wrap_DeviceControl_deviceTLVersionSubMinor_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceGenCPVersionMajor_get", (PyCFunction)_wrap_DeviceControl_deviceGenCPVersionMajor_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceGenCPVersionMinor_get", (PyCFunction)_wrap_DeviceControl_deviceGenCPVersionMinor_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceMaxThroughput_get", (PyCFunction)_wrap_DeviceControl_deviceMaxThroughput_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceConnectionSelector_get", (PyCFunction)_wrap_DeviceControl_deviceConnectionSelector_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceConnectionSpeed_get", (PyCFunction)_wrap_DeviceControl_deviceConnectionSpeed_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceConnectionStatus_get", (PyCFunction)_wrap_DeviceControl_deviceConnectionStatus_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceLinkSelector_get", (PyCFunction)_wrap_DeviceControl_deviceLinkSelector_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceLinkSpeed_get", (PyCFunction)_wrap_DeviceControl_deviceLinkSpeed_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceLinkThroughputLimitMode_get", (PyCFunction)_wrap_DeviceControl_deviceLinkThroughputLimitMode_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceLinkThroughputLimit_get", (PyCFunction)_wrap_DeviceControl_deviceLinkThroughputLimit_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceLinkConnectionCount_get", (PyCFunction)_wrap_DeviceControl_deviceLinkConnectionCount_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceLinkHeartbeatMode_get", (PyCFunction)_wrap_DeviceControl_deviceLinkHeartbeatMode_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceLinkHeartbeatTimeout_get", (PyCFunction)_wrap_DeviceControl_deviceLinkHeartbeatTimeout_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceLinkCommandTimeout_get", (PyCFunction)_wrap_DeviceControl_deviceLinkCommandTimeout_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceStreamChannelCount_get", (PyCFunction)_wrap_DeviceControl_deviceStreamChannelCount_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceStreamChannelSelector_get", (PyCFunction)_wrap_DeviceControl_deviceStreamChannelSelector_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceStreamChannelType_get", (PyCFunction)_wrap_DeviceControl_deviceStreamChannelType_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceStreamChannelLink_get", (PyCFunction)_wrap_DeviceControl_deviceStreamChannelLink_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceStreamChannelEndianness_get", (PyCFunction)_wrap_DeviceControl_deviceStreamChannelEndianness_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceStreamChannelPacketSize_get", (PyCFunction)_wrap_DeviceControl_deviceStreamChannelPacketSize_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceEventChannelCount_get", (PyCFunction)_wrap_DeviceControl_deviceEventChannelCount_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceMessageChannelCount_get", (PyCFunction)_wrap_DeviceControl_deviceMessageChannelCount_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceCharacterSet_get", (PyCFunction)_wrap_DeviceControl_deviceCharacterSet_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceReset_get", (PyCFunction)_wrap_DeviceControl_deviceReset_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceIndicatorMode_get", (PyCFunction)_wrap_DeviceControl_deviceIndicatorMode_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceFeaturePersistenceStart_get", (PyCFunction)_wrap_DeviceControl_deviceFeaturePersistenceStart_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceFeaturePersistenceEnd_get", (PyCFunction)_wrap_DeviceControl_deviceFeaturePersistenceEnd_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceRegistersStreamingStart_get", (PyCFunction)_wrap_DeviceControl_deviceRegistersStreamingStart_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceRegistersStreamingEnd_get", (PyCFunction)_wrap_DeviceControl_deviceRegistersStreamingEnd_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceRegistersCheck_get", (PyCFunction)_wrap_DeviceControl_deviceRegistersCheck_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceRegistersValid_get", (PyCFunction)_wrap_DeviceControl_deviceRegistersValid_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceRegistersEndianness_get", (PyCFunction)_wrap_DeviceControl_deviceRegistersEndianness_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceTemperatureSelector_get", (PyCFunction)_wrap_DeviceControl_deviceTemperatureSelector_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceTemperature_get", (PyCFunction)_wrap_DeviceControl_deviceTemperature_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceClockSelector_get", (PyCFunction)_wrap_DeviceControl_deviceClockSelector_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceClockFrequency_get", (PyCFunction)_wrap_DeviceControl_deviceClockFrequency_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceSerialPortSelector_get", (PyCFunction)_wrap_DeviceControl_deviceSerialPortSelector_get, METH_O, NULL},
	 { (char *)"DeviceControl_deviceSerialPortBaudRate_get", (PyCFunction)_wrap_DeviceControl_deviceSerialPortBaudRate_get, METH_O, NULL},
	 { (char *)"DeviceControl_timestamp_get", (PyCFunction)_wrap_DeviceControl_timestamp_get, METH_O, NULL},
	 { (char *)"DeviceControl_timestampReset_get", (PyCFunction)_wrap_DeviceControl_timestampReset_get, METH_O, NULL},
	 { (char *)"DeviceControl_timestampLatch_get", (PyCFunction)_wrap_DeviceControl_timestampLatch_get, METH_O, NULL},
	 { (char *)"DeviceControl_timestampLatchValue_get", (PyCFunction)_wrap_DeviceControl_timestampLatchValue_get, METH_O, NULL},
	 { (char *)"DeviceControl_mvDeviceTemperatureRaw_get", (PyCFunction)_wrap_DeviceControl_mvDeviceTemperatureRaw_get, METH_O, NULL},
	 { (char *)"DeviceControl_mvDeviceTemperatureUpperLimit_get", (PyCFunction)_wrap_DeviceControl_mvDeviceTemperatureUpperLimit_get, METH_O, NULL},
	 { (char *)"DeviceControl_mvDeviceTemperatureLowerLimit_get", (PyCFunction)_wrap_DeviceControl_mvDeviceTemperatureLowerLimit_get, METH_O, NULL},
	 { (char *)"DeviceControl_mvDeviceTemperatureLimitHysteresis_get", (PyCFunction)_wrap_DeviceControl_mvDeviceTemperatureLimitHysteresis_get, METH_O, NULL},
	 { (char *)"DeviceControl_mvDeviceClockFrequency_get", (PyCFunction)_wrap_DeviceControl_mvDeviceClockFrequency_get, METH_O, NULL},
	 { (char *)"DeviceControl_mvDeviceSensorColorMode_get", (PyCFunction)_wrap_DeviceControl_mvDeviceSensorColorMode_get, METH_O, NULL},
	 { (char *)"DeviceControl_mvDeviceFPGAVersion_get", (PyCFunction)_wrap_DeviceControl_mvDeviceFPGAVersion_get, METH_O, NULL},
	 { (char *)"DeviceControl_mvDeviceFirmwareSource_get", (PyCFunction)_wrap_DeviceControl_mvDeviceFirmwareSource_get, METH_O, NULL},
	 { (char *)"DeviceControl_mvDeviceProcessingUnitSelector_get", (PyCFunction)_wrap_DeviceControl_mvDeviceProcessingUnitSelector_get, METH_O, NULL},
	 { (char *)"DeviceControl_mvDeviceProcessingUnit_get", (PyCFunction)_wrap_DeviceControl_mvDeviceProcessingUnit_get, METH_O, NULL},
	 { (char *)"DeviceControl_mvDeviceStatusLEDEnable_get", (PyCFunction)_wrap_DeviceControl_mvDeviceStatusLEDEnable_get, METH_O, NULL},
	 { (char *)"DeviceControl_mvDevicePowerMode_get", (PyCFunction)_wrap_DeviceControl_mvDevicePowerMode_get, METH_O, NULL},
	 { (char *)"DeviceControl_mvDeviceStandbyTimeoutEnable_get", (PyCFunction)_wrap_DeviceControl_mvDeviceStandbyTimeoutEnable_get, METH_O, NULL},
	 { (char *)"DeviceControl_mvDeviceStandbyTimeout_get", (PyCFunction)_wrap_DeviceControl_mvDeviceStandbyTimeout_get, METH_O, NULL},
	 { (char *)"DeviceControl_mvDeviceFirmwareHashCode_get", (PyCFunction)_wrap_DeviceControl_mvDeviceFirmwareHashCode_get, METH_O, NULL},
	 { (char *)"DeviceControl_mvCalculateHashCode_get", (PyCFunction)_wrap_DeviceControl_mvCalculateHashCode_get, METH_O, NULL},
	 { (char *)"DeviceControl_mvDeviceFirmwareHashAlgorithm_get", (PyCFunction)_wrap_DeviceControl_mvDeviceFirmwareHashAlgorithm_get, METH_O, NULL},
	 { (char *)"DeviceControl_mvDeviceLaserCurrent_get", (PyCFunction)_wrap_DeviceControl_mvDeviceLaserCurrent_get, METH_O, NULL},
	 { (char *)"DeviceControl_mvTimestampPPSSync_get", (PyCFunction)_wrap_DeviceControl_mvTimestampPPSSync_get, METH_O, NULL},
	 { (char *)"delete_DeviceControl", (PyCFunction)_wrap_delete_DeviceControl, METH_O, NULL},
	 { (char *)"DeviceControl_swigregister", DeviceControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"DeviceControl_swiginit", DeviceControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ImageFormatControl", _wrap_new_ImageFormatControl, METH_VARARGS, NULL},
	 { (char *)"ImageFormatControl_sensorWidth_get", (PyCFunction)_wrap_ImageFormatControl_sensorWidth_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_sensorHeight_get", (PyCFunction)_wrap_ImageFormatControl_sensorHeight_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_sensorPixelWidth_get", (PyCFunction)_wrap_ImageFormatControl_sensorPixelWidth_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_sensorPixelHeight_get", (PyCFunction)_wrap_ImageFormatControl_sensorPixelHeight_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_sensorName_get", (PyCFunction)_wrap_ImageFormatControl_sensorName_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_sensorShutterMode_get", (PyCFunction)_wrap_ImageFormatControl_sensorShutterMode_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_sensorTaps_get", (PyCFunction)_wrap_ImageFormatControl_sensorTaps_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_sensorDigitizationTaps_get", (PyCFunction)_wrap_ImageFormatControl_sensorDigitizationTaps_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_widthMax_get", (PyCFunction)_wrap_ImageFormatControl_widthMax_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_heightMax_get", (PyCFunction)_wrap_ImageFormatControl_heightMax_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_regionSelector_get", (PyCFunction)_wrap_ImageFormatControl_regionSelector_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_regionMode_get", (PyCFunction)_wrap_ImageFormatControl_regionMode_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_regionDestination_get", (PyCFunction)_wrap_ImageFormatControl_regionDestination_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_regionIDValue_get", (PyCFunction)_wrap_ImageFormatControl_regionIDValue_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_componentSelector_get", (PyCFunction)_wrap_ImageFormatControl_componentSelector_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_componentEnable_get", (PyCFunction)_wrap_ImageFormatControl_componentEnable_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_componentIDValue_get", (PyCFunction)_wrap_ImageFormatControl_componentIDValue_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_imageComponentSelector_get", (PyCFunction)_wrap_ImageFormatControl_imageComponentSelector_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_imageComponentEnable_get", (PyCFunction)_wrap_ImageFormatControl_imageComponentEnable_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_width_get", (PyCFunction)_wrap_ImageFormatControl_width_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_height_get", (PyCFunction)_wrap_ImageFormatControl_height_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_offsetX_get", (PyCFunction)_wrap_ImageFormatControl_offsetX_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_offsetY_get", (PyCFunction)_wrap_ImageFormatControl_offsetY_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_mvMultiAreaMode_get", (PyCFunction)_wrap_ImageFormatControl_mvMultiAreaMode_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_mvAreaSelector_get", (PyCFunction)_wrap_ImageFormatControl_mvAreaSelector_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_mvAreaEnable_get", (PyCFunction)_wrap_ImageFormatControl_mvAreaEnable_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_mvAreaWidth_get", (PyCFunction)_wrap_ImageFormatControl_mvAreaWidth_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_mvAreaHeight_get", (PyCFunction)_wrap_ImageFormatControl_mvAreaHeight_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_mvAreaOffsetX_get", (PyCFunction)_wrap_ImageFormatControl_mvAreaOffsetX_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_mvAreaOffsetY_get", (PyCFunction)_wrap_ImageFormatControl_mvAreaOffsetY_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_mvAreaResultingOffsetX_get", (PyCFunction)_wrap_ImageFormatControl_mvAreaResultingOffsetX_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_mvAreaResultingOffsetY_get", (PyCFunction)_wrap_ImageFormatControl_mvAreaResultingOffsetY_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_linePitchEnable_get", (PyCFunction)_wrap_ImageFormatControl_linePitchEnable_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_linePitch_get", (PyCFunction)_wrap_ImageFormatControl_linePitch_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_binningSelector_get", (PyCFunction)_wrap_ImageFormatControl_binningSelector_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_binningHorizontalMode_get", (PyCFunction)_wrap_ImageFormatControl_binningHorizontalMode_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_binningHorizontal_get", (PyCFunction)_wrap_ImageFormatControl_binningHorizontal_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_binningVerticalMode_get", (PyCFunction)_wrap_ImageFormatControl_binningVerticalMode_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_binningVertical_get", (PyCFunction)_wrap_ImageFormatControl_binningVertical_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_decimationHorizontalMode_get", (PyCFunction)_wrap_ImageFormatControl_decimationHorizontalMode_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_decimationHorizontal_get", (PyCFunction)_wrap_ImageFormatControl_decimationHorizontal_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_decimationVerticalMode_get", (PyCFunction)_wrap_ImageFormatControl_decimationVerticalMode_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_decimationVertical_get", (PyCFunction)_wrap_ImageFormatControl_decimationVertical_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_reverseX_get", (PyCFunction)_wrap_ImageFormatControl_reverseX_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_reverseY_get", (PyCFunction)_wrap_ImageFormatControl_reverseY_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_pixelFormat_get", (PyCFunction)_wrap_ImageFormatControl_pixelFormat_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_pixelFormatInfoSelector_get", (PyCFunction)_wrap_ImageFormatControl_pixelFormatInfoSelector_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_pixelFormatInfoID_get", (PyCFunction)_wrap_ImageFormatControl_pixelFormatInfoID_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_pixelCoding_get", (PyCFunction)_wrap_ImageFormatControl_pixelCoding_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_pixelSize_get", (PyCFunction)_wrap_ImageFormatControl_pixelSize_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_pixelColorFilter_get", (PyCFunction)_wrap_ImageFormatControl_pixelColorFilter_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_pixelDynamicRangeMin_get", (PyCFunction)_wrap_ImageFormatControl_pixelDynamicRangeMin_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_pixelDynamicRangeMax_get", (PyCFunction)_wrap_ImageFormatControl_pixelDynamicRangeMax_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_testPatternGeneratorSelector_get", (PyCFunction)_wrap_ImageFormatControl_testPatternGeneratorSelector_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_testPattern_get", (PyCFunction)_wrap_ImageFormatControl_testPattern_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_testImageSelector_get", (PyCFunction)_wrap_ImageFormatControl_testImageSelector_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_deinterlacing_get", (PyCFunction)_wrap_ImageFormatControl_deinterlacing_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_imageCompressionMode_get", (PyCFunction)_wrap_ImageFormatControl_imageCompressionMode_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_imageCompressionRateOption_get", (PyCFunction)_wrap_ImageFormatControl_imageCompressionRateOption_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_imageCompressionQuality_get", (PyCFunction)_wrap_ImageFormatControl_imageCompressionQuality_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_imageCompressionBitrate_get", (PyCFunction)_wrap_ImageFormatControl_imageCompressionBitrate_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_imageCompressionJPEGFormatOption_get", (PyCFunction)_wrap_ImageFormatControl_imageCompressionJPEGFormatOption_get, METH_O, NULL},
	 { (char *)"ImageFormatControl_mvSensorDigitizationBitDepth_get", (PyCFunction)_wrap_ImageFormatControl_mvSensorDigitizationBitDepth_get, METH_O, NULL},
	 { (char *)"delete_ImageFormatControl", (PyCFunction)_wrap_delete_ImageFormatControl, METH_O, NULL},
	 { (char *)"ImageFormatControl_swigregister", ImageFormatControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"ImageFormatControl_swiginit", ImageFormatControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_AcquisitionControl", _wrap_new_AcquisitionControl, METH_VARARGS, NULL},
	 { (char *)"AcquisitionControl_acquisitionMode_get", (PyCFunction)_wrap_AcquisitionControl_acquisitionMode_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_acquisitionStopMode_get", (PyCFunction)_wrap_AcquisitionControl_acquisitionStopMode_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_acquisitionArm_get", (PyCFunction)_wrap_AcquisitionControl_acquisitionArm_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_acquisitionFrameCount_get", (PyCFunction)_wrap_AcquisitionControl_acquisitionFrameCount_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_acquisitionBurstFrameCount_get", (PyCFunction)_wrap_AcquisitionControl_acquisitionBurstFrameCount_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvSensorRegister_get", (PyCFunction)_wrap_AcquisitionControl_mvSensorRegister_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvSensorRegisterValue_get", (PyCFunction)_wrap_AcquisitionControl_mvSensorRegisterValue_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_acquisitionFrameRate_get", (PyCFunction)_wrap_AcquisitionControl_acquisitionFrameRate_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_acquisitionFrameRateEnable_get", (PyCFunction)_wrap_AcquisitionControl_acquisitionFrameRateEnable_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_acquisitionLineRate_get", (PyCFunction)_wrap_AcquisitionControl_acquisitionLineRate_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_acquisitionLineRateEnable_get", (PyCFunction)_wrap_AcquisitionControl_acquisitionLineRateEnable_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_acquisitionStatusSelector_get", (PyCFunction)_wrap_AcquisitionControl_acquisitionStatusSelector_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_acquisitionStatus_get", (PyCFunction)_wrap_AcquisitionControl_acquisitionStatus_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_triggerSelector_get", (PyCFunction)_wrap_AcquisitionControl_triggerSelector_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_triggerMode_get", (PyCFunction)_wrap_AcquisitionControl_triggerMode_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_triggerSoftware_get", (PyCFunction)_wrap_AcquisitionControl_triggerSoftware_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_triggerSource_get", (PyCFunction)_wrap_AcquisitionControl_triggerSource_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_triggerActivation_get", (PyCFunction)_wrap_AcquisitionControl_triggerActivation_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_triggerOverlap_get", (PyCFunction)_wrap_AcquisitionControl_triggerOverlap_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_triggerDelay_get", (PyCFunction)_wrap_AcquisitionControl_triggerDelay_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_triggerDivider_get", (PyCFunction)_wrap_AcquisitionControl_triggerDivider_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_triggerMultiplier_get", (PyCFunction)_wrap_AcquisitionControl_triggerMultiplier_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_exposureMode_get", (PyCFunction)_wrap_AcquisitionControl_exposureMode_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_exposureTimeMode_get", (PyCFunction)_wrap_AcquisitionControl_exposureTimeMode_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_exposureTimeSelector_get", (PyCFunction)_wrap_AcquisitionControl_exposureTimeSelector_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_exposureTime_get", (PyCFunction)_wrap_AcquisitionControl_exposureTime_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvExposureHorizontalZoneDivider_get", (PyCFunction)_wrap_AcquisitionControl_mvExposureHorizontalZoneDivider_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_exposureAuto_get", (PyCFunction)_wrap_AcquisitionControl_exposureAuto_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_multiSlopeMode_get", (PyCFunction)_wrap_AcquisitionControl_multiSlopeMode_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_multiSlopeKneePointCount_get", (PyCFunction)_wrap_AcquisitionControl_multiSlopeKneePointCount_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_multiSlopeKneePointSelector_get", (PyCFunction)_wrap_AcquisitionControl_multiSlopeKneePointSelector_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_multiSlopeExposureLimit_get", (PyCFunction)_wrap_AcquisitionControl_multiSlopeExposureLimit_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_multiSlopeSaturationThreshold_get", (PyCFunction)_wrap_AcquisitionControl_multiSlopeSaturationThreshold_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_multiSlopeIntensityLimit_get", (PyCFunction)_wrap_AcquisitionControl_multiSlopeIntensityLimit_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_multiSlopeExposureGradient_get", (PyCFunction)_wrap_AcquisitionControl_multiSlopeExposureGradient_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvAcquisitionFrameRateLimitMode_get", (PyCFunction)_wrap_AcquisitionControl_mvAcquisitionFrameRateLimitMode_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvAcquisitionFrameRateEnable_get", (PyCFunction)_wrap_AcquisitionControl_mvAcquisitionFrameRateEnable_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvResultingFrameRate_get", (PyCFunction)_wrap_AcquisitionControl_mvResultingFrameRate_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvShutterMode_get", (PyCFunction)_wrap_AcquisitionControl_mvShutterMode_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvCompressionKneepoint_get", (PyCFunction)_wrap_AcquisitionControl_mvCompressionKneepoint_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvExposureAutoLowerLimit_get", (PyCFunction)_wrap_AcquisitionControl_mvExposureAutoLowerLimit_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvExposureAutoUpperLimit_get", (PyCFunction)_wrap_AcquisitionControl_mvExposureAutoUpperLimit_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvExposureAutoSpeed_get", (PyCFunction)_wrap_AcquisitionControl_mvExposureAutoSpeed_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvExposureAutoDelayImages_get", (PyCFunction)_wrap_AcquisitionControl_mvExposureAutoDelayImages_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvExposureAutoAverageGrey_get", (PyCFunction)_wrap_AcquisitionControl_mvExposureAutoAverageGrey_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvExposureAutoHighlightAOI_get", (PyCFunction)_wrap_AcquisitionControl_mvExposureAutoHighlightAOI_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvExposureAutoAOIMode_get", (PyCFunction)_wrap_AcquisitionControl_mvExposureAutoAOIMode_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvExposureAutoOffsetX_get", (PyCFunction)_wrap_AcquisitionControl_mvExposureAutoOffsetX_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvExposureAutoOffsetY_get", (PyCFunction)_wrap_AcquisitionControl_mvExposureAutoOffsetY_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvExposureAutoWidth_get", (PyCFunction)_wrap_AcquisitionControl_mvExposureAutoWidth_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvExposureAutoHeight_get", (PyCFunction)_wrap_AcquisitionControl_mvExposureAutoHeight_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvExposureAutoMode_get", (PyCFunction)_wrap_AcquisitionControl_mvExposureAutoMode_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvSmearReduction_get", (PyCFunction)_wrap_AcquisitionControl_mvSmearReduction_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvAcquisitionMemoryMode_get", (PyCFunction)_wrap_AcquisitionControl_mvAcquisitionMemoryMode_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvPretriggerFrameCount_get", (PyCFunction)_wrap_AcquisitionControl_mvPretriggerFrameCount_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvAcquisitionMemoryMaxFrameCount_get", (PyCFunction)_wrap_AcquisitionControl_mvAcquisitionMemoryMaxFrameCount_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvAcquisitionMemoryFrameCount_get", (PyCFunction)_wrap_AcquisitionControl_mvAcquisitionMemoryFrameCount_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvAcquisitionMemoryAOIParameterChanged_get", (PyCFunction)_wrap_AcquisitionControl_mvAcquisitionMemoryAOIParameterChanged_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvFeatureMode_get", (PyCFunction)_wrap_AcquisitionControl_mvFeatureMode_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvSmartFrameRecallEnable_get", (PyCFunction)_wrap_AcquisitionControl_mvSmartFrameRecallEnable_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvSmartFrameRecallTimestampLookupAccuracy_get", (PyCFunction)_wrap_AcquisitionControl_mvSmartFrameRecallTimestampLookupAccuracy_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvSmartFrameRecallFrameSkipRatio_get", (PyCFunction)_wrap_AcquisitionControl_mvSmartFrameRecallFrameSkipRatio_get, METH_O, NULL},
	 { (char *)"AcquisitionControl_mvLensCalibrationEnable_get", (PyCFunction)_wrap_AcquisitionControl_mvLensCalibrationEnable_get, METH_O, NULL},
	 { (char *)"delete_AcquisitionControl", (PyCFunction)_wrap_delete_AcquisitionControl, METH_O, NULL},
	 { (char *)"AcquisitionControl_swigregister", AcquisitionControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"AcquisitionControl_swiginit", AcquisitionControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_AnalogControl", _wrap_new_AnalogControl, METH_VARARGS, NULL},
	 { (char *)"AnalogControl_mvTapBalancingMode_get", (PyCFunction)_wrap_AnalogControl_mvTapBalancingMode_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvGainMode_get", (PyCFunction)_wrap_AnalogControl_mvGainMode_get, METH_O, NULL},
	 { (char *)"AnalogControl_gainSelector_get", (PyCFunction)_wrap_AnalogControl_gainSelector_get, METH_O, NULL},
	 { (char *)"AnalogControl_gain_get", (PyCFunction)_wrap_AnalogControl_gain_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvGainHorizontalZoneDivider_get", (PyCFunction)_wrap_AnalogControl_mvGainHorizontalZoneDivider_get, METH_O, NULL},
	 { (char *)"AnalogControl_gainAuto_get", (PyCFunction)_wrap_AnalogControl_gainAuto_get, METH_O, NULL},
	 { (char *)"AnalogControl_gainAutoBalance_get", (PyCFunction)_wrap_AnalogControl_gainAutoBalance_get, METH_O, NULL},
	 { (char *)"AnalogControl_blackLevelSelector_get", (PyCFunction)_wrap_AnalogControl_blackLevelSelector_get, METH_O, NULL},
	 { (char *)"AnalogControl_blackLevel_get", (PyCFunction)_wrap_AnalogControl_blackLevel_get, METH_O, NULL},
	 { (char *)"AnalogControl_blackLevelAuto_get", (PyCFunction)_wrap_AnalogControl_blackLevelAuto_get, METH_O, NULL},
	 { (char *)"AnalogControl_blackLevelAutoBalance_get", (PyCFunction)_wrap_AnalogControl_blackLevelAutoBalance_get, METH_O, NULL},
	 { (char *)"AnalogControl_whiteClipSelector_get", (PyCFunction)_wrap_AnalogControl_whiteClipSelector_get, METH_O, NULL},
	 { (char *)"AnalogControl_whiteClip_get", (PyCFunction)_wrap_AnalogControl_whiteClip_get, METH_O, NULL},
	 { (char *)"AnalogControl_balanceRatioSelector_get", (PyCFunction)_wrap_AnalogControl_balanceRatioSelector_get, METH_O, NULL},
	 { (char *)"AnalogControl_balanceRatio_get", (PyCFunction)_wrap_AnalogControl_balanceRatio_get, METH_O, NULL},
	 { (char *)"AnalogControl_balanceWhiteAuto_get", (PyCFunction)_wrap_AnalogControl_balanceWhiteAuto_get, METH_O, NULL},
	 { (char *)"AnalogControl_gamma_get", (PyCFunction)_wrap_AnalogControl_gamma_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvGainAutoDelayImages_get", (PyCFunction)_wrap_AnalogControl_mvGainAutoDelayImages_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvGainAutoUpperLimit_get", (PyCFunction)_wrap_AnalogControl_mvGainAutoUpperLimit_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvGainAutoLowerLimit_get", (PyCFunction)_wrap_AnalogControl_mvGainAutoLowerLimit_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvGainAutoSpeed_get", (PyCFunction)_wrap_AnalogControl_mvGainAutoSpeed_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvGainAutoAverageGrey_get", (PyCFunction)_wrap_AnalogControl_mvGainAutoAverageGrey_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvGainAutoHighlightAOI_get", (PyCFunction)_wrap_AnalogControl_mvGainAutoHighlightAOI_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvGainAutoAOIMode_get", (PyCFunction)_wrap_AnalogControl_mvGainAutoAOIMode_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvGainAutoOffsetX_get", (PyCFunction)_wrap_AnalogControl_mvGainAutoOffsetX_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvGainAutoOffsetY_get", (PyCFunction)_wrap_AnalogControl_mvGainAutoOffsetY_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvGainAutoWidth_get", (PyCFunction)_wrap_AnalogControl_mvGainAutoWidth_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvGainAutoHeight_get", (PyCFunction)_wrap_AnalogControl_mvGainAutoHeight_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvGainAutoMode_get", (PyCFunction)_wrap_AnalogControl_mvGainAutoMode_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvBalanceWhiteAutoAOIMode_get", (PyCFunction)_wrap_AnalogControl_mvBalanceWhiteAutoAOIMode_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvBalanceWhiteAutoOffsetX_get", (PyCFunction)_wrap_AnalogControl_mvBalanceWhiteAutoOffsetX_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvBalanceWhiteAutoOffsetY_get", (PyCFunction)_wrap_AnalogControl_mvBalanceWhiteAutoOffsetY_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvBalanceWhiteAutoWidth_get", (PyCFunction)_wrap_AnalogControl_mvBalanceWhiteAutoWidth_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvBalanceWhiteAutoHeight_get", (PyCFunction)_wrap_AnalogControl_mvBalanceWhiteAutoHeight_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvLowLight_get", (PyCFunction)_wrap_AnalogControl_mvLowLight_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvADCGain_get", (PyCFunction)_wrap_AnalogControl_mvADCGain_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvVRamp_get", (PyCFunction)_wrap_AnalogControl_mvVRamp_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvLinearLogarithmicMode_get", (PyCFunction)_wrap_AnalogControl_mvLinearLogarithmicMode_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvDigitalGainOffset_get", (PyCFunction)_wrap_AnalogControl_mvDigitalGainOffset_get, METH_O, NULL},
	 { (char *)"AnalogControl_mvSaveCalibrationData_get", (PyCFunction)_wrap_AnalogControl_mvSaveCalibrationData_get, METH_O, NULL},
	 { (char *)"delete_AnalogControl", (PyCFunction)_wrap_delete_AnalogControl, METH_O, NULL},
	 { (char *)"AnalogControl_swigregister", AnalogControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"AnalogControl_swiginit", AnalogControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_LUTControl", _wrap_new_LUTControl, METH_VARARGS, NULL},
	 { (char *)"LUTControl_LUTSelector_get", (PyCFunction)_wrap_LUTControl_LUTSelector_get, METH_O, NULL},
	 { (char *)"LUTControl_LUTEnable_get", (PyCFunction)_wrap_LUTControl_LUTEnable_get, METH_O, NULL},
	 { (char *)"LUTControl_LUTIndex_get", (PyCFunction)_wrap_LUTControl_LUTIndex_get, METH_O, NULL},
	 { (char *)"LUTControl_LUTValue_get", (PyCFunction)_wrap_LUTControl_LUTValue_get, METH_O, NULL},
	 { (char *)"LUTControl_LUTValueAll_get", (PyCFunction)_wrap_LUTControl_LUTValueAll_get, METH_O, NULL},
	 { (char *)"delete_LUTControl", (PyCFunction)_wrap_delete_LUTControl, METH_O, NULL},
	 { (char *)"LUTControl_swigregister", LUTControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"LUTControl_swiginit", LUTControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ColorTransformationControl", _wrap_new_ColorTransformationControl, METH_VARARGS, NULL},
	 { (char *)"ColorTransformationControl_colorTransformationSelector_get", (PyCFunction)_wrap_ColorTransformationControl_colorTransformationSelector_get, METH_O, NULL},
	 { (char *)"ColorTransformationControl_colorTransformationEnable_get", (PyCFunction)_wrap_ColorTransformationControl_colorTransformationEnable_get, METH_O, NULL},
	 { (char *)"ColorTransformationControl_colorTransformationValueSelector_get", (PyCFunction)_wrap_ColorTransformationControl_colorTransformationValueSelector_get, METH_O, NULL},
	 { (char *)"ColorTransformationControl_colorTransformationValue_get", (PyCFunction)_wrap_ColorTransformationControl_colorTransformationValue_get, METH_O, NULL},
	 { (char *)"delete_ColorTransformationControl", (PyCFunction)_wrap_delete_ColorTransformationControl, METH_O, NULL},
	 { (char *)"ColorTransformationControl_swigregister", ColorTransformationControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"ColorTransformationControl_swiginit", ColorTransformationControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_DigitalIOControl", _wrap_new_DigitalIOControl, METH_VARARGS, NULL},
	 { (char *)"DigitalIOControl_lineSelector_get", (PyCFunction)_wrap_DigitalIOControl_lineSelector_get, METH_O, NULL},
	 { (char *)"DigitalIOControl_lineMode_get", (PyCFunction)_wrap_DigitalIOControl_lineMode_get, METH_O, NULL},
	 { (char *)"DigitalIOControl_lineInverter_get", (PyCFunction)_wrap_DigitalIOControl_lineInverter_get, METH_O, NULL},
	 { (char *)"DigitalIOControl_lineStatus_get", (PyCFunction)_wrap_DigitalIOControl_lineStatus_get, METH_O, NULL},
	 { (char *)"DigitalIOControl_lineStatusAll_get", (PyCFunction)_wrap_DigitalIOControl_lineStatusAll_get, METH_O, NULL},
	 { (char *)"DigitalIOControl_lineSource_get", (PyCFunction)_wrap_DigitalIOControl_lineSource_get, METH_O, NULL},
	 { (char *)"DigitalIOControl_lineFormat_get", (PyCFunction)_wrap_DigitalIOControl_lineFormat_get, METH_O, NULL},
	 { (char *)"DigitalIOControl_userOutputSelector_get", (PyCFunction)_wrap_DigitalIOControl_userOutputSelector_get, METH_O, NULL},
	 { (char *)"DigitalIOControl_userOutputValue_get", (PyCFunction)_wrap_DigitalIOControl_userOutputValue_get, METH_O, NULL},
	 { (char *)"DigitalIOControl_userOutputValueAll_get", (PyCFunction)_wrap_DigitalIOControl_userOutputValueAll_get, METH_O, NULL},
	 { (char *)"DigitalIOControl_userOutputValueAllMask_get", (PyCFunction)_wrap_DigitalIOControl_userOutputValueAllMask_get, METH_O, NULL},
	 { (char *)"DigitalIOControl_mvLineDebounceTimeRisingEdge_get", (PyCFunction)_wrap_DigitalIOControl_mvLineDebounceTimeRisingEdge_get, METH_O, NULL},
	 { (char *)"DigitalIOControl_mvLineDebounceTimeFallingEdge_get", (PyCFunction)_wrap_DigitalIOControl_mvLineDebounceTimeFallingEdge_get, METH_O, NULL},
	 { (char *)"DigitalIOControl_mvRTMInputSelector_get", (PyCFunction)_wrap_DigitalIOControl_mvRTMInputSelector_get, METH_O, NULL},
	 { (char *)"DigitalIOControl_mvRTMSource_get", (PyCFunction)_wrap_DigitalIOControl_mvRTMSource_get, METH_O, NULL},
	 { (char *)"DigitalIOControl_mvLineLED_get", (PyCFunction)_wrap_DigitalIOControl_mvLineLED_get, METH_O, NULL},
	 { (char *)"delete_DigitalIOControl", (PyCFunction)_wrap_delete_DigitalIOControl, METH_O, NULL},
	 { (char *)"DigitalIOControl_swigregister", DigitalIOControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"DigitalIOControl_swiginit", DigitalIOControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_CounterAndTimerControl", _wrap_new_CounterAndTimerControl, METH_VARARGS, NULL},
	 { (char *)"CounterAndTimerControl_counterSelector_get", (PyCFunction)_wrap_CounterAndTimerControl_counterSelector_get, METH_O, NULL},
	 { (char *)"CounterAndTimerControl_counterEventSource_get", (PyCFunction)_wrap_CounterAndTimerControl_counterEventSource_get, METH_O, NULL},
	 { (char *)"CounterAndTimerControl_counterEventActivation_get", (PyCFunction)_wrap_CounterAndTimerControl_counterEventActivation_get, METH_O, NULL},
	 { (char *)"CounterAndTimerControl_counterResetSource_get", (PyCFunction)_wrap_CounterAndTimerControl_counterResetSource_get, METH_O, NULL},
	 { (char *)"CounterAndTimerControl_counterResetActivation_get", (PyCFunction)_wrap_CounterAndTimerControl_counterResetActivation_get, METH_O, NULL},
	 { (char *)"CounterAndTimerControl_counterReset_get", (PyCFunction)_wrap_CounterAndTimerControl_counterReset_get, METH_O, NULL},
	 { (char *)"CounterAndTimerControl_counterValue_get", (PyCFunction)_wrap_CounterAndTimerControl_counterValue_get, METH_O, NULL},
	 { (char *)"CounterAndTimerControl_counterValueAtReset_get", (PyCFunction)_wrap_CounterAndTimerControl_counterValueAtReset_get, METH_O, NULL},
	 { (char *)"CounterAndTimerControl_counterDuration_get", (PyCFunction)_wrap_CounterAndTimerControl_counterDuration_get, METH_O, NULL},
	 { (char *)"CounterAndTimerControl_counterStatus_get", (PyCFunction)_wrap_CounterAndTimerControl_counterStatus_get, METH_O, NULL},
	 { (char *)"CounterAndTimerControl_counterTriggerSource_get", (PyCFunction)_wrap_CounterAndTimerControl_counterTriggerSource_get, METH_O, NULL},
	 { (char *)"CounterAndTimerControl_counterTriggerActivation_get", (PyCFunction)_wrap_CounterAndTimerControl_counterTriggerActivation_get, METH_O, NULL},
	 { (char *)"CounterAndTimerControl_timerSelector_get", (PyCFunction)_wrap_CounterAndTimerControl_timerSelector_get, METH_O, NULL},
	 { (char *)"CounterAndTimerControl_timerDuration_get", (PyCFunction)_wrap_CounterAndTimerControl_timerDuration_get, METH_O, NULL},
	 { (char *)"CounterAndTimerControl_timerDelay_get", (PyCFunction)_wrap_CounterAndTimerControl_timerDelay_get, METH_O, NULL},
	 { (char *)"CounterAndTimerControl_timerReset_get", (PyCFunction)_wrap_CounterAndTimerControl_timerReset_get, METH_O, NULL},
	 { (char *)"CounterAndTimerControl_timerValue_get", (PyCFunction)_wrap_CounterAndTimerControl_timerValue_get, METH_O, NULL},
	 { (char *)"CounterAndTimerControl_timerStatus_get", (PyCFunction)_wrap_CounterAndTimerControl_timerStatus_get, METH_O, NULL},
	 { (char *)"CounterAndTimerControl_timerTriggerSource_get", (PyCFunction)_wrap_CounterAndTimerControl_timerTriggerSource_get, METH_O, NULL},
	 { (char *)"CounterAndTimerControl_timerTriggerActivation_get", (PyCFunction)_wrap_CounterAndTimerControl_timerTriggerActivation_get, METH_O, NULL},
	 { (char *)"CounterAndTimerControl_timerTriggerArmDelay_get", (PyCFunction)_wrap_CounterAndTimerControl_timerTriggerArmDelay_get, METH_O, NULL},
	 { (char *)"delete_CounterAndTimerControl", (PyCFunction)_wrap_delete_CounterAndTimerControl, METH_O, NULL},
	 { (char *)"CounterAndTimerControl_swigregister", CounterAndTimerControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"CounterAndTimerControl_swiginit", CounterAndTimerControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_EncoderControl", _wrap_new_EncoderControl, METH_VARARGS, NULL},
	 { (char *)"EncoderControl_encoderSelector_get", (PyCFunction)_wrap_EncoderControl_encoderSelector_get, METH_O, NULL},
	 { (char *)"EncoderControl_encoderSourceA_get", (PyCFunction)_wrap_EncoderControl_encoderSourceA_get, METH_O, NULL},
	 { (char *)"EncoderControl_encoderSourceB_get", (PyCFunction)_wrap_EncoderControl_encoderSourceB_get, METH_O, NULL},
	 { (char *)"EncoderControl_encoderMode_get", (PyCFunction)_wrap_EncoderControl_encoderMode_get, METH_O, NULL},
	 { (char *)"EncoderControl_encoderDivider_get", (PyCFunction)_wrap_EncoderControl_encoderDivider_get, METH_O, NULL},
	 { (char *)"EncoderControl_encoderOutputMode_get", (PyCFunction)_wrap_EncoderControl_encoderOutputMode_get, METH_O, NULL},
	 { (char *)"EncoderControl_encoderStatus_get", (PyCFunction)_wrap_EncoderControl_encoderStatus_get, METH_O, NULL},
	 { (char *)"EncoderControl_encoderTimeout_get", (PyCFunction)_wrap_EncoderControl_encoderTimeout_get, METH_O, NULL},
	 { (char *)"EncoderControl_encoderResetSource_get", (PyCFunction)_wrap_EncoderControl_encoderResetSource_get, METH_O, NULL},
	 { (char *)"EncoderControl_encoderResetActivation_get", (PyCFunction)_wrap_EncoderControl_encoderResetActivation_get, METH_O, NULL},
	 { (char *)"EncoderControl_encoderReset_get", (PyCFunction)_wrap_EncoderControl_encoderReset_get, METH_O, NULL},
	 { (char *)"EncoderControl_encoderValue_get", (PyCFunction)_wrap_EncoderControl_encoderValue_get, METH_O, NULL},
	 { (char *)"EncoderControl_encoderValueAtReset_get", (PyCFunction)_wrap_EncoderControl_encoderValueAtReset_get, METH_O, NULL},
	 { (char *)"delete_EncoderControl", (PyCFunction)_wrap_delete_EncoderControl, METH_O, NULL},
	 { (char *)"EncoderControl_swigregister", EncoderControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"EncoderControl_swiginit", EncoderControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_LogicBlockControl", _wrap_new_LogicBlockControl, METH_VARARGS, NULL},
	 { (char *)"LogicBlockControl_logicBlockSelector_get", (PyCFunction)_wrap_LogicBlockControl_logicBlockSelector_get, METH_O, NULL},
	 { (char *)"LogicBlockControl_logicBlockFunction_get", (PyCFunction)_wrap_LogicBlockControl_logicBlockFunction_get, METH_O, NULL},
	 { (char *)"LogicBlockControl_logicBlockInputNumber_get", (PyCFunction)_wrap_LogicBlockControl_logicBlockInputNumber_get, METH_O, NULL},
	 { (char *)"LogicBlockControl_logicBlockInputSelector_get", (PyCFunction)_wrap_LogicBlockControl_logicBlockInputSelector_get, METH_O, NULL},
	 { (char *)"LogicBlockControl_logicBlockInputSource_get", (PyCFunction)_wrap_LogicBlockControl_logicBlockInputSource_get, METH_O, NULL},
	 { (char *)"LogicBlockControl_logicBlockInputInverter_get", (PyCFunction)_wrap_LogicBlockControl_logicBlockInputInverter_get, METH_O, NULL},
	 { (char *)"LogicBlockControl_logicBlockLUTIndex_get", (PyCFunction)_wrap_LogicBlockControl_logicBlockLUTIndex_get, METH_O, NULL},
	 { (char *)"LogicBlockControl_logicBlockLUTValue_get", (PyCFunction)_wrap_LogicBlockControl_logicBlockLUTValue_get, METH_O, NULL},
	 { (char *)"LogicBlockControl_logicBlockLUTValueAll_get", (PyCFunction)_wrap_LogicBlockControl_logicBlockLUTValueAll_get, METH_O, NULL},
	 { (char *)"LogicBlockControl_logicBlockLUTSelector_get", (PyCFunction)_wrap_LogicBlockControl_logicBlockLUTSelector_get, METH_O, NULL},
	 { (char *)"delete_LogicBlockControl", (PyCFunction)_wrap_delete_LogicBlockControl, METH_O, NULL},
	 { (char *)"LogicBlockControl_swigregister", LogicBlockControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"LogicBlockControl_swiginit", LogicBlockControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_SoftwareSignalControl", _wrap_new_SoftwareSignalControl, METH_VARARGS, NULL},
	 { (char *)"SoftwareSignalControl_softwareSignalSelector_get", (PyCFunction)_wrap_SoftwareSignalControl_softwareSignalSelector_get, METH_O, NULL},
	 { (char *)"SoftwareSignalControl_softwareSignalPulse_get", (PyCFunction)_wrap_SoftwareSignalControl_softwareSignalPulse_get, METH_O, NULL},
	 { (char *)"delete_SoftwareSignalControl", (PyCFunction)_wrap_delete_SoftwareSignalControl, METH_O, NULL},
	 { (char *)"SoftwareSignalControl_swigregister", SoftwareSignalControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"SoftwareSignalControl_swiginit", SoftwareSignalControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ActionControl", _wrap_new_ActionControl, METH_VARARGS, NULL},
	 { (char *)"ActionControl_actionUnconditionalMode_get", (PyCFunction)_wrap_ActionControl_actionUnconditionalMode_get, METH_O, NULL},
	 { (char *)"ActionControl_actionDeviceKey_get", (PyCFunction)_wrap_ActionControl_actionDeviceKey_get, METH_O, NULL},
	 { (char *)"ActionControl_actionQueueSize_get", (PyCFunction)_wrap_ActionControl_actionQueueSize_get, METH_O, NULL},
	 { (char *)"ActionControl_actionSelector_get", (PyCFunction)_wrap_ActionControl_actionSelector_get, METH_O, NULL},
	 { (char *)"ActionControl_actionGroupMask_get", (PyCFunction)_wrap_ActionControl_actionGroupMask_get, METH_O, NULL},
	 { (char *)"ActionControl_actionGroupKey_get", (PyCFunction)_wrap_ActionControl_actionGroupKey_get, METH_O, NULL},
	 { (char *)"delete_ActionControl", (PyCFunction)_wrap_delete_ActionControl, METH_O, NULL},
	 { (char *)"ActionControl_swigregister", ActionControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"ActionControl_swiginit", ActionControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_EventControl", _wrap_new_EventControl, METH_VARARGS, NULL},
	 { (char *)"EventControl_eventSelector_get", (PyCFunction)_wrap_EventControl_eventSelector_get, METH_O, NULL},
	 { (char *)"EventControl_eventNotification_get", (PyCFunction)_wrap_EventControl_eventNotification_get, METH_O, NULL},
	 { (char *)"EventControl_eventAcquisitionTrigger_get", (PyCFunction)_wrap_EventControl_eventAcquisitionTrigger_get, METH_O, NULL},
	 { (char *)"EventControl_eventAcquisitionTriggerTimestamp_get", (PyCFunction)_wrap_EventControl_eventAcquisitionTriggerTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventAcquisitionTriggerFrameID_get", (PyCFunction)_wrap_EventControl_eventAcquisitionTriggerFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventAcquisitionTriggerMissed_get", (PyCFunction)_wrap_EventControl_eventAcquisitionTriggerMissed_get, METH_O, NULL},
	 { (char *)"EventControl_eventAcquisitionTriggerMissedTimestamp_get", (PyCFunction)_wrap_EventControl_eventAcquisitionTriggerMissedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventAcquisitionTriggerMissedFrameID_get", (PyCFunction)_wrap_EventControl_eventAcquisitionTriggerMissedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventAcquisitionStart_get", (PyCFunction)_wrap_EventControl_eventAcquisitionStart_get, METH_O, NULL},
	 { (char *)"EventControl_eventAcquisitionStartTimestamp_get", (PyCFunction)_wrap_EventControl_eventAcquisitionStartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventAcquisitionStartFrameID_get", (PyCFunction)_wrap_EventControl_eventAcquisitionStartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventAcquisitionEnd_get", (PyCFunction)_wrap_EventControl_eventAcquisitionEnd_get, METH_O, NULL},
	 { (char *)"EventControl_eventAcquisitionEndTimestamp_get", (PyCFunction)_wrap_EventControl_eventAcquisitionEndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventAcquisitionEndFrameID_get", (PyCFunction)_wrap_EventControl_eventAcquisitionEndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventAcquisitionTransferStart_get", (PyCFunction)_wrap_EventControl_eventAcquisitionTransferStart_get, METH_O, NULL},
	 { (char *)"EventControl_eventAcquisitionTransferStartTimestamp_get", (PyCFunction)_wrap_EventControl_eventAcquisitionTransferStartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventAcquisitionTransferStartFrameID_get", (PyCFunction)_wrap_EventControl_eventAcquisitionTransferStartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventAcquisitionTransferEnd_get", (PyCFunction)_wrap_EventControl_eventAcquisitionTransferEnd_get, METH_O, NULL},
	 { (char *)"EventControl_eventAcquisitionTransferEndTimestamp_get", (PyCFunction)_wrap_EventControl_eventAcquisitionTransferEndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventAcquisitionTransferEndFrameID_get", (PyCFunction)_wrap_EventControl_eventAcquisitionTransferEndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventAcquisitionError_get", (PyCFunction)_wrap_EventControl_eventAcquisitionError_get, METH_O, NULL},
	 { (char *)"EventControl_eventAcquisitionErrorTimestamp_get", (PyCFunction)_wrap_EventControl_eventAcquisitionErrorTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventAcquisitionErrorFrameID_get", (PyCFunction)_wrap_EventControl_eventAcquisitionErrorFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameBurstStart_get", (PyCFunction)_wrap_EventControl_eventFrameBurstStart_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameBurstStartTimestamp_get", (PyCFunction)_wrap_EventControl_eventFrameBurstStartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameBurstStartFrameID_get", (PyCFunction)_wrap_EventControl_eventFrameBurstStartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameBurstEnd_get", (PyCFunction)_wrap_EventControl_eventFrameBurstEnd_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameBurstEndTimestamp_get", (PyCFunction)_wrap_EventControl_eventFrameBurstEndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameBurstEndFrameID_get", (PyCFunction)_wrap_EventControl_eventFrameBurstEndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameTrigger_get", (PyCFunction)_wrap_EventControl_eventFrameTrigger_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameTriggerTimestamp_get", (PyCFunction)_wrap_EventControl_eventFrameTriggerTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameTriggerFrameID_get", (PyCFunction)_wrap_EventControl_eventFrameTriggerFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameTriggerMissed_get", (PyCFunction)_wrap_EventControl_eventFrameTriggerMissed_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameTriggerMissedTimestamp_get", (PyCFunction)_wrap_EventControl_eventFrameTriggerMissedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameTriggerMissedFrameID_get", (PyCFunction)_wrap_EventControl_eventFrameTriggerMissedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameStart_get", (PyCFunction)_wrap_EventControl_eventFrameStart_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameStartTimestamp_get", (PyCFunction)_wrap_EventControl_eventFrameStartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameStartFrameID_get", (PyCFunction)_wrap_EventControl_eventFrameStartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameEnd_get", (PyCFunction)_wrap_EventControl_eventFrameEnd_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameEndTimestamp_get", (PyCFunction)_wrap_EventControl_eventFrameEndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameEndFrameID_get", (PyCFunction)_wrap_EventControl_eventFrameEndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameTransferStart_get", (PyCFunction)_wrap_EventControl_eventFrameTransferStart_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameTransferStartTimestamp_get", (PyCFunction)_wrap_EventControl_eventFrameTransferStartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameTransferStartFrameID_get", (PyCFunction)_wrap_EventControl_eventFrameTransferStartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameTransferEnd_get", (PyCFunction)_wrap_EventControl_eventFrameTransferEnd_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameTransferEndTimestamp_get", (PyCFunction)_wrap_EventControl_eventFrameTransferEndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventFrameTransferEndFrameID_get", (PyCFunction)_wrap_EventControl_eventFrameTransferEndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLineTrigger_get", (PyCFunction)_wrap_EventControl_eventLineTrigger_get, METH_O, NULL},
	 { (char *)"EventControl_eventLineTriggerTimestamp_get", (PyCFunction)_wrap_EventControl_eventLineTriggerTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLineTriggerFrameID_get", (PyCFunction)_wrap_EventControl_eventLineTriggerFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLineTriggerMissed_get", (PyCFunction)_wrap_EventControl_eventLineTriggerMissed_get, METH_O, NULL},
	 { (char *)"EventControl_eventLineTriggerMissedTimestamp_get", (PyCFunction)_wrap_EventControl_eventLineTriggerMissedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLineTriggerMissedFrameID_get", (PyCFunction)_wrap_EventControl_eventLineTriggerMissedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLineStart_get", (PyCFunction)_wrap_EventControl_eventLineStart_get, METH_O, NULL},
	 { (char *)"EventControl_eventLineStartTimestamp_get", (PyCFunction)_wrap_EventControl_eventLineStartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLineStartFrameID_get", (PyCFunction)_wrap_EventControl_eventLineStartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLineEnd_get", (PyCFunction)_wrap_EventControl_eventLineEnd_get, METH_O, NULL},
	 { (char *)"EventControl_eventLineEndTimestamp_get", (PyCFunction)_wrap_EventControl_eventLineEndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLineEndFrameID_get", (PyCFunction)_wrap_EventControl_eventLineEndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventExposureStart_get", (PyCFunction)_wrap_EventControl_eventExposureStart_get, METH_O, NULL},
	 { (char *)"EventControl_eventExposureStartTimestamp_get", (PyCFunction)_wrap_EventControl_eventExposureStartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventExposureStartFrameID_get", (PyCFunction)_wrap_EventControl_eventExposureStartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventExposureEnd_get", (PyCFunction)_wrap_EventControl_eventExposureEnd_get, METH_O, NULL},
	 { (char *)"EventControl_eventExposureEndTimestamp_get", (PyCFunction)_wrap_EventControl_eventExposureEndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventExposureEndFrameID_get", (PyCFunction)_wrap_EventControl_eventExposureEndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventActionLate_get", (PyCFunction)_wrap_EventControl_eventActionLate_get, METH_O, NULL},
	 { (char *)"EventControl_eventActionLateTimestamp_get", (PyCFunction)_wrap_EventControl_eventActionLateTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventActionLateFrameID_get", (PyCFunction)_wrap_EventControl_eventActionLateFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventPrimaryApplicationSwitch_get", (PyCFunction)_wrap_EventControl_eventPrimaryApplicationSwitch_get, METH_O, NULL},
	 { (char *)"EventControl_eventPrimaryApplicationSwitchTimestamp_get", (PyCFunction)_wrap_EventControl_eventPrimaryApplicationSwitchTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventPrimaryApplicationSwitchFrameID_get", (PyCFunction)_wrap_EventControl_eventPrimaryApplicationSwitchFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTest_get", (PyCFunction)_wrap_EventControl_eventTest_get, METH_O, NULL},
	 { (char *)"EventControl_eventTestTimestamp_get", (PyCFunction)_wrap_EventControl_eventTestTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter0Start_get", (PyCFunction)_wrap_EventControl_eventCounter0Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter0StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter0StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter0StartFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter0StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter1Start_get", (PyCFunction)_wrap_EventControl_eventCounter1Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter1StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter1StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter1StartFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter1StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter2Start_get", (PyCFunction)_wrap_EventControl_eventCounter2Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter2StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter2StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter2StartFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter2StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter3Start_get", (PyCFunction)_wrap_EventControl_eventCounter3Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter3StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter3StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter3StartFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter3StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter4Start_get", (PyCFunction)_wrap_EventControl_eventCounter4Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter4StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter4StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter4StartFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter4StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter5Start_get", (PyCFunction)_wrap_EventControl_eventCounter5Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter5StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter5StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter5StartFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter5StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter6Start_get", (PyCFunction)_wrap_EventControl_eventCounter6Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter6StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter6StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter6StartFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter6StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter7Start_get", (PyCFunction)_wrap_EventControl_eventCounter7Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter7StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter7StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter7StartFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter7StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter8Start_get", (PyCFunction)_wrap_EventControl_eventCounter8Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter8StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter8StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter8StartFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter8StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter9Start_get", (PyCFunction)_wrap_EventControl_eventCounter9Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter9StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter9StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter9StartFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter9StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter10Start_get", (PyCFunction)_wrap_EventControl_eventCounter10Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter10StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter10StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter10StartFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter10StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter11Start_get", (PyCFunction)_wrap_EventControl_eventCounter11Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter11StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter11StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter11StartFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter11StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter12Start_get", (PyCFunction)_wrap_EventControl_eventCounter12Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter12StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter12StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter12StartFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter12StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter13Start_get", (PyCFunction)_wrap_EventControl_eventCounter13Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter13StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter13StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter13StartFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter13StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter14Start_get", (PyCFunction)_wrap_EventControl_eventCounter14Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter14StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter14StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter14StartFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter14StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter0End_get", (PyCFunction)_wrap_EventControl_eventCounter0End_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter0EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter0EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter0EndFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter0EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter1End_get", (PyCFunction)_wrap_EventControl_eventCounter1End_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter1EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter1EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter1EndFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter1EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter2End_get", (PyCFunction)_wrap_EventControl_eventCounter2End_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter2EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter2EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter2EndFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter2EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter3End_get", (PyCFunction)_wrap_EventControl_eventCounter3End_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter3EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter3EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter3EndFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter3EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter4End_get", (PyCFunction)_wrap_EventControl_eventCounter4End_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter4EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter4EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter4EndFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter4EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter5End_get", (PyCFunction)_wrap_EventControl_eventCounter5End_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter5EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter5EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter5EndFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter5EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter6End_get", (PyCFunction)_wrap_EventControl_eventCounter6End_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter6EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter6EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter6EndFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter6EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter7End_get", (PyCFunction)_wrap_EventControl_eventCounter7End_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter7EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter7EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter7EndFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter7EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter8End_get", (PyCFunction)_wrap_EventControl_eventCounter8End_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter8EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter8EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter8EndFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter8EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter9End_get", (PyCFunction)_wrap_EventControl_eventCounter9End_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter9EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter9EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter9EndFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter9EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter10End_get", (PyCFunction)_wrap_EventControl_eventCounter10End_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter10EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter10EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter10EndFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter10EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter11End_get", (PyCFunction)_wrap_EventControl_eventCounter11End_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter11EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter11EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter11EndFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter11EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter12End_get", (PyCFunction)_wrap_EventControl_eventCounter12End_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter12EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter12EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter12EndFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter12EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter13End_get", (PyCFunction)_wrap_EventControl_eventCounter13End_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter13EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter13EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter13EndFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter13EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter14End_get", (PyCFunction)_wrap_EventControl_eventCounter14End_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter14EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventCounter14EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventCounter14EndFrameID_get", (PyCFunction)_wrap_EventControl_eventCounter14EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer0Start_get", (PyCFunction)_wrap_EventControl_eventTimer0Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer0StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer0StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer0StartFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer0StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer1Start_get", (PyCFunction)_wrap_EventControl_eventTimer1Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer1StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer1StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer1StartFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer1StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer2Start_get", (PyCFunction)_wrap_EventControl_eventTimer2Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer2StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer2StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer2StartFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer2StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer3Start_get", (PyCFunction)_wrap_EventControl_eventTimer3Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer3StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer3StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer3StartFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer3StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer4Start_get", (PyCFunction)_wrap_EventControl_eventTimer4Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer4StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer4StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer4StartFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer4StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer5Start_get", (PyCFunction)_wrap_EventControl_eventTimer5Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer5StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer5StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer5StartFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer5StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer6Start_get", (PyCFunction)_wrap_EventControl_eventTimer6Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer6StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer6StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer6StartFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer6StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer7Start_get", (PyCFunction)_wrap_EventControl_eventTimer7Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer7StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer7StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer7StartFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer7StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer8Start_get", (PyCFunction)_wrap_EventControl_eventTimer8Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer8StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer8StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer8StartFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer8StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer9Start_get", (PyCFunction)_wrap_EventControl_eventTimer9Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer9StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer9StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer9StartFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer9StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer10Start_get", (PyCFunction)_wrap_EventControl_eventTimer10Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer10StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer10StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer10StartFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer10StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer11Start_get", (PyCFunction)_wrap_EventControl_eventTimer11Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer11StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer11StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer11StartFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer11StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer12Start_get", (PyCFunction)_wrap_EventControl_eventTimer12Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer12StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer12StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer12StartFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer12StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer13Start_get", (PyCFunction)_wrap_EventControl_eventTimer13Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer13StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer13StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer13StartFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer13StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer14Start_get", (PyCFunction)_wrap_EventControl_eventTimer14Start_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer14StartTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer14StartTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer14StartFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer14StartFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer0End_get", (PyCFunction)_wrap_EventControl_eventTimer0End_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer0EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer0EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer0EndFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer0EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer1End_get", (PyCFunction)_wrap_EventControl_eventTimer1End_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer1EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer1EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer1EndFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer1EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer2End_get", (PyCFunction)_wrap_EventControl_eventTimer2End_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer2EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer2EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer2EndFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer2EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer3End_get", (PyCFunction)_wrap_EventControl_eventTimer3End_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer3EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer3EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer3EndFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer3EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer4End_get", (PyCFunction)_wrap_EventControl_eventTimer4End_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer4EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer4EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer4EndFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer4EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer5End_get", (PyCFunction)_wrap_EventControl_eventTimer5End_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer5EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer5EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer5EndFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer5EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer6End_get", (PyCFunction)_wrap_EventControl_eventTimer6End_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer6EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer6EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer6EndFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer6EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer7End_get", (PyCFunction)_wrap_EventControl_eventTimer7End_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer7EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer7EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer7EndFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer7EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer8End_get", (PyCFunction)_wrap_EventControl_eventTimer8End_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer8EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer8EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer8EndFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer8EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer9End_get", (PyCFunction)_wrap_EventControl_eventTimer9End_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer9EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer9EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer9EndFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer9EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer10End_get", (PyCFunction)_wrap_EventControl_eventTimer10End_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer10EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer10EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer10EndFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer10EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer11End_get", (PyCFunction)_wrap_EventControl_eventTimer11End_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer11EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer11EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer11EndFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer11EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer12End_get", (PyCFunction)_wrap_EventControl_eventTimer12End_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer12EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer12EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer12EndFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer12EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer13End_get", (PyCFunction)_wrap_EventControl_eventTimer13End_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer13EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer13EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer13EndFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer13EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer14End_get", (PyCFunction)_wrap_EventControl_eventTimer14End_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer14EndTimestamp_get", (PyCFunction)_wrap_EventControl_eventTimer14EndTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventTimer14EndFrameID_get", (PyCFunction)_wrap_EventControl_eventTimer14EndFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder0Stopped_get", (PyCFunction)_wrap_EventControl_eventEncoder0Stopped_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder0StoppedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder0StoppedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder0StoppedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder0StoppedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder1Stopped_get", (PyCFunction)_wrap_EventControl_eventEncoder1Stopped_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder1StoppedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder1StoppedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder1StoppedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder1StoppedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder2Stopped_get", (PyCFunction)_wrap_EventControl_eventEncoder2Stopped_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder2StoppedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder2StoppedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder2StoppedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder2StoppedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder3Stopped_get", (PyCFunction)_wrap_EventControl_eventEncoder3Stopped_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder3StoppedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder3StoppedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder3StoppedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder3StoppedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder4Stopped_get", (PyCFunction)_wrap_EventControl_eventEncoder4Stopped_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder4StoppedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder4StoppedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder4StoppedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder4StoppedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder5Stopped_get", (PyCFunction)_wrap_EventControl_eventEncoder5Stopped_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder5StoppedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder5StoppedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder5StoppedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder5StoppedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder6Stopped_get", (PyCFunction)_wrap_EventControl_eventEncoder6Stopped_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder6StoppedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder6StoppedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder6StoppedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder6StoppedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder7Stopped_get", (PyCFunction)_wrap_EventControl_eventEncoder7Stopped_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder7StoppedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder7StoppedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder7StoppedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder7StoppedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder8Stopped_get", (PyCFunction)_wrap_EventControl_eventEncoder8Stopped_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder8StoppedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder8StoppedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder8StoppedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder8StoppedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder9Stopped_get", (PyCFunction)_wrap_EventControl_eventEncoder9Stopped_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder9StoppedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder9StoppedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder9StoppedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder9StoppedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder10Stopped_get", (PyCFunction)_wrap_EventControl_eventEncoder10Stopped_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder10StoppedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder10StoppedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder10StoppedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder10StoppedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder11Stopped_get", (PyCFunction)_wrap_EventControl_eventEncoder11Stopped_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder11StoppedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder11StoppedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder11StoppedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder11StoppedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder12Stopped_get", (PyCFunction)_wrap_EventControl_eventEncoder12Stopped_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder12StoppedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder12StoppedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder12StoppedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder12StoppedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder13Stopped_get", (PyCFunction)_wrap_EventControl_eventEncoder13Stopped_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder13StoppedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder13StoppedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder13StoppedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder13StoppedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder14Stopped_get", (PyCFunction)_wrap_EventControl_eventEncoder14Stopped_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder14StoppedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder14StoppedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder14StoppedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder14StoppedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder0Restarted_get", (PyCFunction)_wrap_EventControl_eventEncoder0Restarted_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder0RestartedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder0RestartedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder0RestartedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder0RestartedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder1Restarted_get", (PyCFunction)_wrap_EventControl_eventEncoder1Restarted_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder1RestartedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder1RestartedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder1RestartedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder1RestartedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder2Restarted_get", (PyCFunction)_wrap_EventControl_eventEncoder2Restarted_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder2RestartedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder2RestartedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder2RestartedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder2RestartedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder3Restarted_get", (PyCFunction)_wrap_EventControl_eventEncoder3Restarted_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder3RestartedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder3RestartedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder3RestartedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder3RestartedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder4Restarted_get", (PyCFunction)_wrap_EventControl_eventEncoder4Restarted_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder4RestartedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder4RestartedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder4RestartedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder4RestartedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder5Restarted_get", (PyCFunction)_wrap_EventControl_eventEncoder5Restarted_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder5RestartedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder5RestartedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder5RestartedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder5RestartedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder6Restarted_get", (PyCFunction)_wrap_EventControl_eventEncoder6Restarted_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder6RestartedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder6RestartedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder6RestartedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder6RestartedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder7Restarted_get", (PyCFunction)_wrap_EventControl_eventEncoder7Restarted_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder7RestartedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder7RestartedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder7RestartedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder7RestartedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder8Restarted_get", (PyCFunction)_wrap_EventControl_eventEncoder8Restarted_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder8RestartedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder8RestartedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder8RestartedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder8RestartedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder9Restarted_get", (PyCFunction)_wrap_EventControl_eventEncoder9Restarted_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder9RestartedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder9RestartedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder9RestartedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder9RestartedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder10Restarted_get", (PyCFunction)_wrap_EventControl_eventEncoder10Restarted_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder10RestartedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder10RestartedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder10RestartedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder10RestartedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder11Restarted_get", (PyCFunction)_wrap_EventControl_eventEncoder11Restarted_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder11RestartedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder11RestartedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder11RestartedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder11RestartedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder12Restarted_get", (PyCFunction)_wrap_EventControl_eventEncoder12Restarted_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder12RestartedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder12RestartedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder12RestartedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder12RestartedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder13Restarted_get", (PyCFunction)_wrap_EventControl_eventEncoder13Restarted_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder13RestartedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder13RestartedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder13RestartedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder13RestartedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder14Restarted_get", (PyCFunction)_wrap_EventControl_eventEncoder14Restarted_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder14RestartedTimestamp_get", (PyCFunction)_wrap_EventControl_eventEncoder14RestartedTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventEncoder14RestartedFrameID_get", (PyCFunction)_wrap_EventControl_eventEncoder14RestartedFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine0RisingEdge_get", (PyCFunction)_wrap_EventControl_eventLine0RisingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine0RisingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine0RisingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine0RisingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine0RisingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine1RisingEdge_get", (PyCFunction)_wrap_EventControl_eventLine1RisingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine1RisingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine1RisingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine1RisingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine1RisingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine2RisingEdge_get", (PyCFunction)_wrap_EventControl_eventLine2RisingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine2RisingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine2RisingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine2RisingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine2RisingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine3RisingEdge_get", (PyCFunction)_wrap_EventControl_eventLine3RisingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine3RisingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine3RisingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine3RisingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine3RisingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine4RisingEdge_get", (PyCFunction)_wrap_EventControl_eventLine4RisingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine4RisingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine4RisingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine4RisingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine4RisingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine5RisingEdge_get", (PyCFunction)_wrap_EventControl_eventLine5RisingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine5RisingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine5RisingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine5RisingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine5RisingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine6RisingEdge_get", (PyCFunction)_wrap_EventControl_eventLine6RisingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine6RisingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine6RisingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine6RisingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine6RisingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine7RisingEdge_get", (PyCFunction)_wrap_EventControl_eventLine7RisingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine7RisingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine7RisingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine7RisingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine7RisingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine8RisingEdge_get", (PyCFunction)_wrap_EventControl_eventLine8RisingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine8RisingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine8RisingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine8RisingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine8RisingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine9RisingEdge_get", (PyCFunction)_wrap_EventControl_eventLine9RisingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine9RisingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine9RisingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine9RisingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine9RisingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine10RisingEdge_get", (PyCFunction)_wrap_EventControl_eventLine10RisingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine10RisingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine10RisingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine10RisingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine10RisingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine11RisingEdge_get", (PyCFunction)_wrap_EventControl_eventLine11RisingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine11RisingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine11RisingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine11RisingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine11RisingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine12RisingEdge_get", (PyCFunction)_wrap_EventControl_eventLine12RisingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine12RisingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine12RisingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine12RisingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine12RisingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine13RisingEdge_get", (PyCFunction)_wrap_EventControl_eventLine13RisingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine13RisingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine13RisingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine13RisingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine13RisingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine14RisingEdge_get", (PyCFunction)_wrap_EventControl_eventLine14RisingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine14RisingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine14RisingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine14RisingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine14RisingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine0FallingEdge_get", (PyCFunction)_wrap_EventControl_eventLine0FallingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine0FallingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine0FallingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine0FallingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine0FallingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine1FallingEdge_get", (PyCFunction)_wrap_EventControl_eventLine1FallingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine1FallingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine1FallingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine1FallingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine1FallingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine2FallingEdge_get", (PyCFunction)_wrap_EventControl_eventLine2FallingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine2FallingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine2FallingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine2FallingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine2FallingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine3FallingEdge_get", (PyCFunction)_wrap_EventControl_eventLine3FallingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine3FallingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine3FallingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine3FallingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine3FallingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine4FallingEdge_get", (PyCFunction)_wrap_EventControl_eventLine4FallingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine4FallingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine4FallingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine4FallingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine4FallingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine5FallingEdge_get", (PyCFunction)_wrap_EventControl_eventLine5FallingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine5FallingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine5FallingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine5FallingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine5FallingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine6FallingEdge_get", (PyCFunction)_wrap_EventControl_eventLine6FallingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine6FallingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine6FallingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine6FallingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine6FallingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine7FallingEdge_get", (PyCFunction)_wrap_EventControl_eventLine7FallingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine7FallingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine7FallingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine7FallingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine7FallingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine8FallingEdge_get", (PyCFunction)_wrap_EventControl_eventLine8FallingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine8FallingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine8FallingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine8FallingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine8FallingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine9FallingEdge_get", (PyCFunction)_wrap_EventControl_eventLine9FallingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine9FallingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine9FallingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine9FallingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine9FallingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine10FallingEdge_get", (PyCFunction)_wrap_EventControl_eventLine10FallingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine10FallingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine10FallingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine10FallingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine10FallingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine11FallingEdge_get", (PyCFunction)_wrap_EventControl_eventLine11FallingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine11FallingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine11FallingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine11FallingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine11FallingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine12FallingEdge_get", (PyCFunction)_wrap_EventControl_eventLine12FallingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine12FallingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine12FallingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine12FallingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine12FallingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine13FallingEdge_get", (PyCFunction)_wrap_EventControl_eventLine13FallingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine13FallingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine13FallingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine13FallingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine13FallingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine14FallingEdge_get", (PyCFunction)_wrap_EventControl_eventLine14FallingEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine14FallingEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine14FallingEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine14FallingEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine14FallingEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine0AnyEdge_get", (PyCFunction)_wrap_EventControl_eventLine0AnyEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine0AnyEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine0AnyEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine0AnyEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine0AnyEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine1AnyEdge_get", (PyCFunction)_wrap_EventControl_eventLine1AnyEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine1AnyEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine1AnyEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine1AnyEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine1AnyEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine2AnyEdge_get", (PyCFunction)_wrap_EventControl_eventLine2AnyEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine2AnyEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine2AnyEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine2AnyEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine2AnyEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine3AnyEdge_get", (PyCFunction)_wrap_EventControl_eventLine3AnyEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine3AnyEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine3AnyEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine3AnyEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine3AnyEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine4AnyEdge_get", (PyCFunction)_wrap_EventControl_eventLine4AnyEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine4AnyEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine4AnyEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine4AnyEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine4AnyEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine5AnyEdge_get", (PyCFunction)_wrap_EventControl_eventLine5AnyEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine5AnyEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine5AnyEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine5AnyEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine5AnyEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine6AnyEdge_get", (PyCFunction)_wrap_EventControl_eventLine6AnyEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine6AnyEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine6AnyEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine6AnyEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine6AnyEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine7AnyEdge_get", (PyCFunction)_wrap_EventControl_eventLine7AnyEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine7AnyEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine7AnyEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine7AnyEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine7AnyEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine8AnyEdge_get", (PyCFunction)_wrap_EventControl_eventLine8AnyEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine8AnyEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine8AnyEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine8AnyEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine8AnyEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine9AnyEdge_get", (PyCFunction)_wrap_EventControl_eventLine9AnyEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine9AnyEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine9AnyEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine9AnyEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine9AnyEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine10AnyEdge_get", (PyCFunction)_wrap_EventControl_eventLine10AnyEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine10AnyEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine10AnyEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine10AnyEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine10AnyEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine11AnyEdge_get", (PyCFunction)_wrap_EventControl_eventLine11AnyEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine11AnyEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine11AnyEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine11AnyEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine11AnyEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine12AnyEdge_get", (PyCFunction)_wrap_EventControl_eventLine12AnyEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine12AnyEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine12AnyEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine12AnyEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine12AnyEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine13AnyEdge_get", (PyCFunction)_wrap_EventControl_eventLine13AnyEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine13AnyEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine13AnyEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine13AnyEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine13AnyEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine14AnyEdge_get", (PyCFunction)_wrap_EventControl_eventLine14AnyEdge_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine14AnyEdgeTimestamp_get", (PyCFunction)_wrap_EventControl_eventLine14AnyEdgeTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLine14AnyEdgeFrameID_get", (PyCFunction)_wrap_EventControl_eventLine14AnyEdgeFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger0_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger0_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger0Timestamp_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger0Timestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger0FrameID_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger0FrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger1_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger1_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger1Timestamp_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger1Timestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger1FrameID_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger1FrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger2_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger2_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger2Timestamp_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger2Timestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger2FrameID_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger2FrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger3_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger3_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger3Timestamp_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger3Timestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger3FrameID_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger3FrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger4_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger4_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger4Timestamp_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger4Timestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger4FrameID_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger4FrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger5_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger5_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger5Timestamp_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger5Timestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger5FrameID_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger5FrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger6_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger6_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger6Timestamp_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger6Timestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger6FrameID_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger6FrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger7_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger7_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger7Timestamp_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger7Timestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger7FrameID_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger7FrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger8_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger8_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger8Timestamp_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger8Timestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger8FrameID_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger8FrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger9_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger9_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger9Timestamp_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger9Timestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger9FrameID_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger9FrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger10_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger10_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger10Timestamp_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger10Timestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger10FrameID_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger10FrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger11_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger11_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger11Timestamp_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger11Timestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger11FrameID_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger11FrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger12_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger12_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger12Timestamp_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger12Timestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger12FrameID_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger12FrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger13_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger13_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger13Timestamp_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger13Timestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger13FrameID_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger13FrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger14_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger14_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger14Timestamp_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger14Timestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventLinkTrigger14FrameID_get", (PyCFunction)_wrap_EventControl_eventLinkTrigger14FrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventError_get", (PyCFunction)_wrap_EventControl_eventError_get, METH_O, NULL},
	 { (char *)"EventControl_eventErrorTimestamp_get", (PyCFunction)_wrap_EventControl_eventErrorTimestamp_get, METH_O, NULL},
	 { (char *)"EventControl_eventErrorFrameID_get", (PyCFunction)_wrap_EventControl_eventErrorFrameID_get, METH_O, NULL},
	 { (char *)"EventControl_eventErrorCode_get", (PyCFunction)_wrap_EventControl_eventErrorCode_get, METH_O, NULL},
	 { (char *)"delete_EventControl", (PyCFunction)_wrap_delete_EventControl, METH_O, NULL},
	 { (char *)"EventControl_swigregister", EventControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"EventControl_swiginit", EventControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_UserSetControl", _wrap_new_UserSetControl, METH_VARARGS, NULL},
	 { (char *)"UserSetControl_userSetSelector_get", (PyCFunction)_wrap_UserSetControl_userSetSelector_get, METH_O, NULL},
	 { (char *)"UserSetControl_userSetLoad_get", (PyCFunction)_wrap_UserSetControl_userSetLoad_get, METH_O, NULL},
	 { (char *)"UserSetControl_userSetSave_get", (PyCFunction)_wrap_UserSetControl_userSetSave_get, METH_O, NULL},
	 { (char *)"UserSetControl_userSetDefault_get", (PyCFunction)_wrap_UserSetControl_userSetDefault_get, METH_O, NULL},
	 { (char *)"UserSetControl_userSetDefaultSelector_get", (PyCFunction)_wrap_UserSetControl_userSetDefaultSelector_get, METH_O, NULL},
	 { (char *)"UserSetControl_userSetFeatureSelector_get", (PyCFunction)_wrap_UserSetControl_userSetFeatureSelector_get, METH_O, NULL},
	 { (char *)"UserSetControl_userSetFeatureEnable_get", (PyCFunction)_wrap_UserSetControl_userSetFeatureEnable_get, METH_O, NULL},
	 { (char *)"UserSetControl_mvUserData_get", (PyCFunction)_wrap_UserSetControl_mvUserData_get, METH_O, NULL},
	 { (char *)"delete_UserSetControl", (PyCFunction)_wrap_delete_UserSetControl, METH_O, NULL},
	 { (char *)"UserSetControl_swigregister", UserSetControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"UserSetControl_swiginit", UserSetControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_SequencerControl", _wrap_new_SequencerControl, METH_VARARGS, NULL},
	 { (char *)"SequencerControl_sequencerMode_get", (PyCFunction)_wrap_SequencerControl_sequencerMode_get, METH_O, NULL},
	 { (char *)"SequencerControl_sequencerConfigurationMode_get", (PyCFunction)_wrap_SequencerControl_sequencerConfigurationMode_get, METH_O, NULL},
	 { (char *)"SequencerControl_sequencerFeatureSelector_get", (PyCFunction)_wrap_SequencerControl_sequencerFeatureSelector_get, METH_O, NULL},
	 { (char *)"SequencerControl_sequencerFeatureEnable_get", (PyCFunction)_wrap_SequencerControl_sequencerFeatureEnable_get, METH_O, NULL},
	 { (char *)"SequencerControl_sequencerSetSelector_get", (PyCFunction)_wrap_SequencerControl_sequencerSetSelector_get, METH_O, NULL},
	 { (char *)"SequencerControl_sequencerSetSave_get", (PyCFunction)_wrap_SequencerControl_sequencerSetSave_get, METH_O, NULL},
	 { (char *)"SequencerControl_sequencerSetLoad_get", (PyCFunction)_wrap_SequencerControl_sequencerSetLoad_get, METH_O, NULL},
	 { (char *)"SequencerControl_sequencerSetActive_get", (PyCFunction)_wrap_SequencerControl_sequencerSetActive_get, METH_O, NULL},
	 { (char *)"SequencerControl_sequencerSetStart_get", (PyCFunction)_wrap_SequencerControl_sequencerSetStart_get, METH_O, NULL},
	 { (char *)"SequencerControl_sequencerPathSelector_get", (PyCFunction)_wrap_SequencerControl_sequencerPathSelector_get, METH_O, NULL},
	 { (char *)"SequencerControl_sequencerSetNext_get", (PyCFunction)_wrap_SequencerControl_sequencerSetNext_get, METH_O, NULL},
	 { (char *)"SequencerControl_sequencerTriggerSource_get", (PyCFunction)_wrap_SequencerControl_sequencerTriggerSource_get, METH_O, NULL},
	 { (char *)"SequencerControl_sequencerTriggerActivation_get", (PyCFunction)_wrap_SequencerControl_sequencerTriggerActivation_get, METH_O, NULL},
	 { (char *)"delete_SequencerControl", (PyCFunction)_wrap_delete_SequencerControl, METH_O, NULL},
	 { (char *)"SequencerControl_swigregister", SequencerControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"SequencerControl_swiginit", SequencerControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_mvDefectivePixelCorrectionControl", _wrap_new_mvDefectivePixelCorrectionControl, METH_VARARGS, NULL},
	 { (char *)"mvDefectivePixelCorrectionControl_mvDefectivePixelEnable_get", (PyCFunction)_wrap_mvDefectivePixelCorrectionControl_mvDefectivePixelEnable_get, METH_O, NULL},
	 { (char *)"mvDefectivePixelCorrectionControl_mvDefectivePixelSelector_get", (PyCFunction)_wrap_mvDefectivePixelCorrectionControl_mvDefectivePixelSelector_get, METH_O, NULL},
	 { (char *)"mvDefectivePixelCorrectionControl_mvDefectivePixelOffsetX_get", (PyCFunction)_wrap_mvDefectivePixelCorrectionControl_mvDefectivePixelOffsetX_get, METH_O, NULL},
	 { (char *)"mvDefectivePixelCorrectionControl_mvDefectivePixelOffsetY_get", (PyCFunction)_wrap_mvDefectivePixelCorrectionControl_mvDefectivePixelOffsetY_get, METH_O, NULL},
	 { (char *)"mvDefectivePixelCorrectionControl_mvDefectivePixelCount_get", (PyCFunction)_wrap_mvDefectivePixelCorrectionControl_mvDefectivePixelCount_get, METH_O, NULL},
	 { (char *)"mvDefectivePixelCorrectionControl_mvDefectivePixelDataLoad_get", (PyCFunction)_wrap_mvDefectivePixelCorrectionControl_mvDefectivePixelDataLoad_get, METH_O, NULL},
	 { (char *)"mvDefectivePixelCorrectionControl_mvDefectivePixelDataSave_get", (PyCFunction)_wrap_mvDefectivePixelCorrectionControl_mvDefectivePixelDataSave_get, METH_O, NULL},
	 { (char *)"delete_mvDefectivePixelCorrectionControl", (PyCFunction)_wrap_delete_mvDefectivePixelCorrectionControl, METH_O, NULL},
	 { (char *)"mvDefectivePixelCorrectionControl_swigregister", mvDefectivePixelCorrectionControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"mvDefectivePixelCorrectionControl_swiginit", mvDefectivePixelCorrectionControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_FileAccessControl", _wrap_new_FileAccessControl, METH_VARARGS, NULL},
	 { (char *)"FileAccessControl_fileSelector_get", (PyCFunction)_wrap_FileAccessControl_fileSelector_get, METH_O, NULL},
	 { (char *)"FileAccessControl_fileOperationSelector_get", (PyCFunction)_wrap_FileAccessControl_fileOperationSelector_get, METH_O, NULL},
	 { (char *)"FileAccessControl_fileOperationExecute_get", (PyCFunction)_wrap_FileAccessControl_fileOperationExecute_get, METH_O, NULL},
	 { (char *)"FileAccessControl_fileOpenMode_get", (PyCFunction)_wrap_FileAccessControl_fileOpenMode_get, METH_O, NULL},
	 { (char *)"FileAccessControl_fileAccessBuffer_get", (PyCFunction)_wrap_FileAccessControl_fileAccessBuffer_get, METH_O, NULL},
	 { (char *)"FileAccessControl_fileAccessOffset_get", (PyCFunction)_wrap_FileAccessControl_fileAccessOffset_get, METH_O, NULL},
	 { (char *)"FileAccessControl_fileAccessLength_get", (PyCFunction)_wrap_FileAccessControl_fileAccessLength_get, METH_O, NULL},
	 { (char *)"FileAccessControl_fileOperationStatus_get", (PyCFunction)_wrap_FileAccessControl_fileOperationStatus_get, METH_O, NULL},
	 { (char *)"FileAccessControl_fileOperationResult_get", (PyCFunction)_wrap_FileAccessControl_fileOperationResult_get, METH_O, NULL},
	 { (char *)"FileAccessControl_fileSize_get", (PyCFunction)_wrap_FileAccessControl_fileSize_get, METH_O, NULL},
	 { (char *)"delete_FileAccessControl", (PyCFunction)_wrap_delete_FileAccessControl, METH_O, NULL},
	 { (char *)"FileAccessControl_swigregister", FileAccessControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"FileAccessControl_swiginit", FileAccessControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_SourceControl", _wrap_new_SourceControl, METH_VARARGS, NULL},
	 { (char *)"SourceControl_sourceCount_get", (PyCFunction)_wrap_SourceControl_sourceCount_get, METH_O, NULL},
	 { (char *)"SourceControl_sourceSelector_get", (PyCFunction)_wrap_SourceControl_sourceSelector_get, METH_O, NULL},
	 { (char *)"SourceControl_sourceIDValue_get", (PyCFunction)_wrap_SourceControl_sourceIDValue_get, METH_O, NULL},
	 { (char *)"delete_SourceControl", (PyCFunction)_wrap_delete_SourceControl, METH_O, NULL},
	 { (char *)"SourceControl_swigregister", SourceControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"SourceControl_swiginit", SourceControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_TransferControl", _wrap_new_TransferControl, METH_VARARGS, NULL},
	 { (char *)"TransferControl_transferSelector_get", (PyCFunction)_wrap_TransferControl_transferSelector_get, METH_O, NULL},
	 { (char *)"TransferControl_transferControlMode_get", (PyCFunction)_wrap_TransferControl_transferControlMode_get, METH_O, NULL},
	 { (char *)"TransferControl_transferOperationMode_get", (PyCFunction)_wrap_TransferControl_transferOperationMode_get, METH_O, NULL},
	 { (char *)"TransferControl_transferBlockCount_get", (PyCFunction)_wrap_TransferControl_transferBlockCount_get, METH_O, NULL},
	 { (char *)"TransferControl_transferBurstCount_get", (PyCFunction)_wrap_TransferControl_transferBurstCount_get, METH_O, NULL},
	 { (char *)"TransferControl_transferQueueMaxBlockCount_get", (PyCFunction)_wrap_TransferControl_transferQueueMaxBlockCount_get, METH_O, NULL},
	 { (char *)"TransferControl_transferQueueCurrentBlockCount_get", (PyCFunction)_wrap_TransferControl_transferQueueCurrentBlockCount_get, METH_O, NULL},
	 { (char *)"TransferControl_transferQueueMode_get", (PyCFunction)_wrap_TransferControl_transferQueueMode_get, METH_O, NULL},
	 { (char *)"TransferControl_transferStart_get", (PyCFunction)_wrap_TransferControl_transferStart_get, METH_O, NULL},
	 { (char *)"TransferControl_transferStop_get", (PyCFunction)_wrap_TransferControl_transferStop_get, METH_O, NULL},
	 { (char *)"TransferControl_transferAbort_get", (PyCFunction)_wrap_TransferControl_transferAbort_get, METH_O, NULL},
	 { (char *)"TransferControl_transferPause_get", (PyCFunction)_wrap_TransferControl_transferPause_get, METH_O, NULL},
	 { (char *)"TransferControl_transferResume_get", (PyCFunction)_wrap_TransferControl_transferResume_get, METH_O, NULL},
	 { (char *)"TransferControl_transferTriggerSelector_get", (PyCFunction)_wrap_TransferControl_transferTriggerSelector_get, METH_O, NULL},
	 { (char *)"TransferControl_transferTriggerMode_get", (PyCFunction)_wrap_TransferControl_transferTriggerMode_get, METH_O, NULL},
	 { (char *)"TransferControl_transferTriggerSource_get", (PyCFunction)_wrap_TransferControl_transferTriggerSource_get, METH_O, NULL},
	 { (char *)"TransferControl_transferTriggerActivation_get", (PyCFunction)_wrap_TransferControl_transferTriggerActivation_get, METH_O, NULL},
	 { (char *)"TransferControl_transferStatusSelector_get", (PyCFunction)_wrap_TransferControl_transferStatusSelector_get, METH_O, NULL},
	 { (char *)"TransferControl_transferStatus_get", (PyCFunction)_wrap_TransferControl_transferStatus_get, METH_O, NULL},
	 { (char *)"TransferControl_transferComponentSelector_get", (PyCFunction)_wrap_TransferControl_transferComponentSelector_get, METH_O, NULL},
	 { (char *)"TransferControl_transferStreamChannel_get", (PyCFunction)_wrap_TransferControl_transferStreamChannel_get, METH_O, NULL},
	 { (char *)"delete_TransferControl", (PyCFunction)_wrap_delete_TransferControl, METH_O, NULL},
	 { (char *)"TransferControl_swigregister", TransferControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"TransferControl_swiginit", TransferControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_Scan3dControl", _wrap_new_Scan3dControl, METH_VARARGS, NULL},
	 { (char *)"Scan3dControl_scan3dExtractionSelector_get", (PyCFunction)_wrap_Scan3dControl_scan3dExtractionSelector_get, METH_O, NULL},
	 { (char *)"Scan3dControl_scan3dExtractionSource_get", (PyCFunction)_wrap_Scan3dControl_scan3dExtractionSource_get, METH_O, NULL},
	 { (char *)"Scan3dControl_scan3dExtractionMethod_get", (PyCFunction)_wrap_Scan3dControl_scan3dExtractionMethod_get, METH_O, NULL},
	 { (char *)"Scan3dControl_scan3dDistanceUnit_get", (PyCFunction)_wrap_Scan3dControl_scan3dDistanceUnit_get, METH_O, NULL},
	 { (char *)"Scan3dControl_scan3dCoordinateSystem_get", (PyCFunction)_wrap_Scan3dControl_scan3dCoordinateSystem_get, METH_O, NULL},
	 { (char *)"Scan3dControl_scan3dOutputMode_get", (PyCFunction)_wrap_Scan3dControl_scan3dOutputMode_get, METH_O, NULL},
	 { (char *)"Scan3dControl_scan3dCoordinateSystemReference_get", (PyCFunction)_wrap_Scan3dControl_scan3dCoordinateSystemReference_get, METH_O, NULL},
	 { (char *)"Scan3dControl_scan3dCoordinateSelector_get", (PyCFunction)_wrap_Scan3dControl_scan3dCoordinateSelector_get, METH_O, NULL},
	 { (char *)"Scan3dControl_scan3dCoordinateScale_get", (PyCFunction)_wrap_Scan3dControl_scan3dCoordinateScale_get, METH_O, NULL},
	 { (char *)"Scan3dControl_scan3dCoordinateOffset_get", (PyCFunction)_wrap_Scan3dControl_scan3dCoordinateOffset_get, METH_O, NULL},
	 { (char *)"Scan3dControl_scan3dInvalidDataFlag_get", (PyCFunction)_wrap_Scan3dControl_scan3dInvalidDataFlag_get, METH_O, NULL},
	 { (char *)"Scan3dControl_scan3dInvalidDataValue_get", (PyCFunction)_wrap_Scan3dControl_scan3dInvalidDataValue_get, METH_O, NULL},
	 { (char *)"Scan3dControl_scan3dAxisMin_get", (PyCFunction)_wrap_Scan3dControl_scan3dAxisMin_get, METH_O, NULL},
	 { (char *)"Scan3dControl_scan3dAxisMax_get", (PyCFunction)_wrap_Scan3dControl_scan3dAxisMax_get, METH_O, NULL},
	 { (char *)"Scan3dControl_scan3dCoordinateTransformSelector_get", (PyCFunction)_wrap_Scan3dControl_scan3dCoordinateTransformSelector_get, METH_O, NULL},
	 { (char *)"Scan3dControl_scan3dTransformValue_get", (PyCFunction)_wrap_Scan3dControl_scan3dTransformValue_get, METH_O, NULL},
	 { (char *)"Scan3dControl_scan3dCoordinateReferenceSelector_get", (PyCFunction)_wrap_Scan3dControl_scan3dCoordinateReferenceSelector_get, METH_O, NULL},
	 { (char *)"Scan3dControl_scan3dCoordinateReferenceValue_get", (PyCFunction)_wrap_Scan3dControl_scan3dCoordinateReferenceValue_get, METH_O, NULL},
	 { (char *)"Scan3dControl_scan3dFocalLength_get", (PyCFunction)_wrap_Scan3dControl_scan3dFocalLength_get, METH_O, NULL},
	 { (char *)"Scan3dControl_scan3dBaseline_get", (PyCFunction)_wrap_Scan3dControl_scan3dBaseline_get, METH_O, NULL},
	 { (char *)"Scan3dControl_scan3dPrincipalPointU_get", (PyCFunction)_wrap_Scan3dControl_scan3dPrincipalPointU_get, METH_O, NULL},
	 { (char *)"Scan3dControl_scan3dPrincipalPointV_get", (PyCFunction)_wrap_Scan3dControl_scan3dPrincipalPointV_get, METH_O, NULL},
	 { (char *)"delete_Scan3dControl", (PyCFunction)_wrap_delete_Scan3dControl, METH_O, NULL},
	 { (char *)"Scan3dControl_swigregister", Scan3dControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"Scan3dControl_swiginit", Scan3dControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_LightControl", _wrap_new_LightControl, METH_VARARGS, NULL},
	 { (char *)"LightControl_lightControllerSelector_get", (PyCFunction)_wrap_LightControl_lightControllerSelector_get, METH_O, NULL},
	 { (char *)"LightControl_lightControllerSource_get", (PyCFunction)_wrap_LightControl_lightControllerSource_get, METH_O, NULL},
	 { (char *)"LightControl_lightCurrentRating_get", (PyCFunction)_wrap_LightControl_lightCurrentRating_get, METH_O, NULL},
	 { (char *)"LightControl_lightVoltageRating_get", (PyCFunction)_wrap_LightControl_lightVoltageRating_get, METH_O, NULL},
	 { (char *)"LightControl_lightBrightness_get", (PyCFunction)_wrap_LightControl_lightBrightness_get, METH_O, NULL},
	 { (char *)"LightControl_lightConnectionStatus_get", (PyCFunction)_wrap_LightControl_lightConnectionStatus_get, METH_O, NULL},
	 { (char *)"LightControl_lightCurrentMeasured_get", (PyCFunction)_wrap_LightControl_lightCurrentMeasured_get, METH_O, NULL},
	 { (char *)"LightControl_lightVoltageMeasured_get", (PyCFunction)_wrap_LightControl_lightVoltageMeasured_get, METH_O, NULL},
	 { (char *)"delete_LightControl", (PyCFunction)_wrap_delete_LightControl, METH_O, NULL},
	 { (char *)"LightControl_swigregister", LightControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"LightControl_swiginit", LightControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_ChunkDataControl", _wrap_new_ChunkDataControl, METH_VARARGS, NULL},
	 { (char *)"ChunkDataControl_chunkModeActive_get", (PyCFunction)_wrap_ChunkDataControl_chunkModeActive_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkSelector_get", (PyCFunction)_wrap_ChunkDataControl_chunkSelector_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkEnable_get", (PyCFunction)_wrap_ChunkDataControl_chunkEnable_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkRegionSelector_get", (PyCFunction)_wrap_ChunkDataControl_chunkRegionSelector_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkRegionID_get", (PyCFunction)_wrap_ChunkDataControl_chunkRegionID_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkRegionIDValue_get", (PyCFunction)_wrap_ChunkDataControl_chunkRegionIDValue_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkComponentSelector_get", (PyCFunction)_wrap_ChunkDataControl_chunkComponentSelector_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkComponentID_get", (PyCFunction)_wrap_ChunkDataControl_chunkComponentID_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkComponentIDValue_get", (PyCFunction)_wrap_ChunkDataControl_chunkComponentIDValue_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkImageComponent_get", (PyCFunction)_wrap_ChunkDataControl_chunkImageComponent_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkPartSelector_get", (PyCFunction)_wrap_ChunkDataControl_chunkPartSelector_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkImage_get", (PyCFunction)_wrap_ChunkDataControl_chunkImage_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkOffsetX_get", (PyCFunction)_wrap_ChunkDataControl_chunkOffsetX_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkOffsetY_get", (PyCFunction)_wrap_ChunkDataControl_chunkOffsetY_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkWidth_get", (PyCFunction)_wrap_ChunkDataControl_chunkWidth_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkHeight_get", (PyCFunction)_wrap_ChunkDataControl_chunkHeight_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkPixelFormat_get", (PyCFunction)_wrap_ChunkDataControl_chunkPixelFormat_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkPixelDynamicRangeMin_get", (PyCFunction)_wrap_ChunkDataControl_chunkPixelDynamicRangeMin_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkPixelDynamicRangeMax_get", (PyCFunction)_wrap_ChunkDataControl_chunkPixelDynamicRangeMax_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkTimestamp_get", (PyCFunction)_wrap_ChunkDataControl_chunkTimestamp_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkTimestampLatchValue_get", (PyCFunction)_wrap_ChunkDataControl_chunkTimestampLatchValue_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkLineStatusAll_get", (PyCFunction)_wrap_ChunkDataControl_chunkLineStatusAll_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkCounterSelector_get", (PyCFunction)_wrap_ChunkDataControl_chunkCounterSelector_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkCounterValue_get", (PyCFunction)_wrap_ChunkDataControl_chunkCounterValue_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkTimerSelector_get", (PyCFunction)_wrap_ChunkDataControl_chunkTimerSelector_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkTimerValue_get", (PyCFunction)_wrap_ChunkDataControl_chunkTimerValue_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkScanLineSelector_get", (PyCFunction)_wrap_ChunkDataControl_chunkScanLineSelector_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkEncoderSelector_get", (PyCFunction)_wrap_ChunkDataControl_chunkEncoderSelector_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkEncoderValue_get", (PyCFunction)_wrap_ChunkDataControl_chunkEncoderValue_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkEncoderStatus_get", (PyCFunction)_wrap_ChunkDataControl_chunkEncoderStatus_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkExposureTimeSelector_get", (PyCFunction)_wrap_ChunkDataControl_chunkExposureTimeSelector_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkExposureTime_get", (PyCFunction)_wrap_ChunkDataControl_chunkExposureTime_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkGainSelector_get", (PyCFunction)_wrap_ChunkDataControl_chunkGainSelector_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkGain_get", (PyCFunction)_wrap_ChunkDataControl_chunkGain_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkBlackLevelSelector_get", (PyCFunction)_wrap_ChunkDataControl_chunkBlackLevelSelector_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkBlackLevel_get", (PyCFunction)_wrap_ChunkDataControl_chunkBlackLevel_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkLinePitch_get", (PyCFunction)_wrap_ChunkDataControl_chunkLinePitch_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkFrameID_get", (PyCFunction)_wrap_ChunkDataControl_chunkFrameID_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkSourceSelector_get", (PyCFunction)_wrap_ChunkDataControl_chunkSourceSelector_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkSourceID_get", (PyCFunction)_wrap_ChunkDataControl_chunkSourceID_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkSourceIDValue_get", (PyCFunction)_wrap_ChunkDataControl_chunkSourceIDValue_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkTransferBlockID_get", (PyCFunction)_wrap_ChunkDataControl_chunkTransferBlockID_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkTransferStreamID_get", (PyCFunction)_wrap_ChunkDataControl_chunkTransferStreamID_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkTransferQueueCurrentBlockCount_get", (PyCFunction)_wrap_ChunkDataControl_chunkTransferQueueCurrentBlockCount_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkStreamChannelID_get", (PyCFunction)_wrap_ChunkDataControl_chunkStreamChannelID_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkSequencerSetActive_get", (PyCFunction)_wrap_ChunkDataControl_chunkSequencerSetActive_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkScan3dDistanceUnit_get", (PyCFunction)_wrap_ChunkDataControl_chunkScan3dDistanceUnit_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkScan3dOutputMode_get", (PyCFunction)_wrap_ChunkDataControl_chunkScan3dOutputMode_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkScan3dCoordinateSystem_get", (PyCFunction)_wrap_ChunkDataControl_chunkScan3dCoordinateSystem_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkScan3dCoordinateSystemReference_get", (PyCFunction)_wrap_ChunkDataControl_chunkScan3dCoordinateSystemReference_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkScan3dCoordinateSelector_get", (PyCFunction)_wrap_ChunkDataControl_chunkScan3dCoordinateSelector_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkScan3dCoordinateScale_get", (PyCFunction)_wrap_ChunkDataControl_chunkScan3dCoordinateScale_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkScan3dCoordinateOffset_get", (PyCFunction)_wrap_ChunkDataControl_chunkScan3dCoordinateOffset_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkScan3dInvalidDataFlag_get", (PyCFunction)_wrap_ChunkDataControl_chunkScan3dInvalidDataFlag_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkScan3dInvalidDataValue_get", (PyCFunction)_wrap_ChunkDataControl_chunkScan3dInvalidDataValue_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkScan3dAxisMin_get", (PyCFunction)_wrap_ChunkDataControl_chunkScan3dAxisMin_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkScan3dAxisMax_get", (PyCFunction)_wrap_ChunkDataControl_chunkScan3dAxisMax_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkScan3dCoordinateTransformSelector_get", (PyCFunction)_wrap_ChunkDataControl_chunkScan3dCoordinateTransformSelector_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkScan3dTransformValue_get", (PyCFunction)_wrap_ChunkDataControl_chunkScan3dTransformValue_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkScan3dCoordinateReferenceSelector_get", (PyCFunction)_wrap_ChunkDataControl_chunkScan3dCoordinateReferenceSelector_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkScan3dCoordinateReferenceValue_get", (PyCFunction)_wrap_ChunkDataControl_chunkScan3dCoordinateReferenceValue_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkScan3dFocalLength_get", (PyCFunction)_wrap_ChunkDataControl_chunkScan3dFocalLength_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkScan3dBaseline_get", (PyCFunction)_wrap_ChunkDataControl_chunkScan3dBaseline_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkScan3dPrincipalPointU_get", (PyCFunction)_wrap_ChunkDataControl_chunkScan3dPrincipalPointU_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkScan3dPrincipalPointV_get", (PyCFunction)_wrap_ChunkDataControl_chunkScan3dPrincipalPointV_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_mvChunkJPEG_get", (PyCFunction)_wrap_ChunkDataControl_mvChunkJPEG_get, METH_O, NULL},
	 { (char *)"ChunkDataControl_chunkmvCustomIdentifier_get", (PyCFunction)_wrap_ChunkDataControl_chunkmvCustomIdentifier_get, METH_O, NULL},
	 { (char *)"delete_ChunkDataControl", (PyCFunction)_wrap_delete_ChunkDataControl, METH_O, NULL},
	 { (char *)"ChunkDataControl_swigregister", ChunkDataControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"ChunkDataControl_swiginit", ChunkDataControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_TestControl", _wrap_new_TestControl, METH_VARARGS, NULL},
	 { (char *)"TestControl_testPendingAck_get", (PyCFunction)_wrap_TestControl_testPendingAck_get, METH_O, NULL},
	 { (char *)"TestControl_testEventGenerate_get", (PyCFunction)_wrap_TestControl_testEventGenerate_get, METH_O, NULL},
	 { (char *)"TestControl_testPayloadFormatMode_get", (PyCFunction)_wrap_TestControl_testPayloadFormatMode_get, METH_O, NULL},
	 { (char *)"delete_TestControl", (PyCFunction)_wrap_delete_TestControl, METH_O, NULL},
	 { (char *)"TestControl_swigregister", TestControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"TestControl_swiginit", TestControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_TransportLayerControl", _wrap_new_TransportLayerControl, METH_VARARGS, NULL},
	 { (char *)"TransportLayerControl_payloadSize_get", (PyCFunction)_wrap_TransportLayerControl_payloadSize_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_mvU3VPHYErrorCount_get", (PyCFunction)_wrap_TransportLayerControl_mvU3VPHYErrorCount_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_mvU3VLNKErrorCount_get", (PyCFunction)_wrap_TransportLayerControl_mvU3VLNKErrorCount_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_mvU3VEndpointSelector_get", (PyCFunction)_wrap_TransportLayerControl_mvU3VEndpointSelector_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_mvU3VEndpointResetEventCount_get", (PyCFunction)_wrap_TransportLayerControl_mvU3VEndpointResetEventCount_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_mvU3VEndpointRetryEventCount_get", (PyCFunction)_wrap_TransportLayerControl_mvU3VEndpointRetryEventCount_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_mvU3VErrorCounterReset_get", (PyCFunction)_wrap_TransportLayerControl_mvU3VErrorCounterReset_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_mvU3VSpreadSpectrumClockingSupportDisable_get", (PyCFunction)_wrap_TransportLayerControl_mvU3VSpreadSpectrumClockingSupportDisable_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_deviceTapGeometry_get", (PyCFunction)_wrap_TransportLayerControl_deviceTapGeometry_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_ptpEnable_get", (PyCFunction)_wrap_TransportLayerControl_ptpEnable_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_ptpClockAccuracy_get", (PyCFunction)_wrap_TransportLayerControl_ptpClockAccuracy_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_ptpDataSetLatch_get", (PyCFunction)_wrap_TransportLayerControl_ptpDataSetLatch_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_ptpStatus_get", (PyCFunction)_wrap_TransportLayerControl_ptpStatus_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_ptpServoStatus_get", (PyCFunction)_wrap_TransportLayerControl_ptpServoStatus_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_ptpOffsetFromMaster_get", (PyCFunction)_wrap_TransportLayerControl_ptpOffsetFromMaster_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_ptpClockId_get", (PyCFunction)_wrap_TransportLayerControl_ptpClockId_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_ptpParentClockId_get", (PyCFunction)_wrap_TransportLayerControl_ptpParentClockId_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_ptpGrandmasterClockID_get", (PyCFunction)_wrap_TransportLayerControl_ptpGrandmasterClockID_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevVersionMajor_get", (PyCFunction)_wrap_TransportLayerControl_gevVersionMajor_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevVersionMinor_get", (PyCFunction)_wrap_TransportLayerControl_gevVersionMinor_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevDeviceModeIsBigEndian_get", (PyCFunction)_wrap_TransportLayerControl_gevDeviceModeIsBigEndian_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevDeviceClass_get", (PyCFunction)_wrap_TransportLayerControl_gevDeviceClass_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevDeviceModeCharacterSet_get", (PyCFunction)_wrap_TransportLayerControl_gevDeviceModeCharacterSet_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevPhysicalLinkConfiguration_get", (PyCFunction)_wrap_TransportLayerControl_gevPhysicalLinkConfiguration_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevCurrentPhysicalLinkConfiguration_get", (PyCFunction)_wrap_TransportLayerControl_gevCurrentPhysicalLinkConfiguration_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevActiveLinkCount_get", (PyCFunction)_wrap_TransportLayerControl_gevActiveLinkCount_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevSupportedOptionSelector_get", (PyCFunction)_wrap_TransportLayerControl_gevSupportedOptionSelector_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevSupportedOption_get", (PyCFunction)_wrap_TransportLayerControl_gevSupportedOption_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevInterfaceSelector_get", (PyCFunction)_wrap_TransportLayerControl_gevInterfaceSelector_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevLinkSpeed_get", (PyCFunction)_wrap_TransportLayerControl_gevLinkSpeed_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevMACAddress_get", (PyCFunction)_wrap_TransportLayerControl_gevMACAddress_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevPAUSEFrameReception_get", (PyCFunction)_wrap_TransportLayerControl_gevPAUSEFrameReception_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevPAUSEFrameTransmission_get", (PyCFunction)_wrap_TransportLayerControl_gevPAUSEFrameTransmission_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevCurrentIPConfigurationLLA_get", (PyCFunction)_wrap_TransportLayerControl_gevCurrentIPConfigurationLLA_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevCurrentIPConfigurationDHCP_get", (PyCFunction)_wrap_TransportLayerControl_gevCurrentIPConfigurationDHCP_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevCurrentIPConfigurationPersistentIP_get", (PyCFunction)_wrap_TransportLayerControl_gevCurrentIPConfigurationPersistentIP_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevCurrentIPAddress_get", (PyCFunction)_wrap_TransportLayerControl_gevCurrentIPAddress_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevCurrentSubnetMask_get", (PyCFunction)_wrap_TransportLayerControl_gevCurrentSubnetMask_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevCurrentDefaultGateway_get", (PyCFunction)_wrap_TransportLayerControl_gevCurrentDefaultGateway_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevIPConfigurationStatus_get", (PyCFunction)_wrap_TransportLayerControl_gevIPConfigurationStatus_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevFirstURL_get", (PyCFunction)_wrap_TransportLayerControl_gevFirstURL_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevSecondURL_get", (PyCFunction)_wrap_TransportLayerControl_gevSecondURL_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevNumberOfInterfaces_get", (PyCFunction)_wrap_TransportLayerControl_gevNumberOfInterfaces_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevPersistentIPAddress_get", (PyCFunction)_wrap_TransportLayerControl_gevPersistentIPAddress_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevPersistentSubnetMask_get", (PyCFunction)_wrap_TransportLayerControl_gevPersistentSubnetMask_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevPersistentDefaultGateway_get", (PyCFunction)_wrap_TransportLayerControl_gevPersistentDefaultGateway_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevMessageChannelCount_get", (PyCFunction)_wrap_TransportLayerControl_gevMessageChannelCount_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevStreamChannelCount_get", (PyCFunction)_wrap_TransportLayerControl_gevStreamChannelCount_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevHeartbeatTimeout_get", (PyCFunction)_wrap_TransportLayerControl_gevHeartbeatTimeout_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevTimestampTickFrequency_get", (PyCFunction)_wrap_TransportLayerControl_gevTimestampTickFrequency_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevTimestampControlLatch_get", (PyCFunction)_wrap_TransportLayerControl_gevTimestampControlLatch_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevTimestampControlReset_get", (PyCFunction)_wrap_TransportLayerControl_gevTimestampControlReset_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevTimestampValue_get", (PyCFunction)_wrap_TransportLayerControl_gevTimestampValue_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevDiscoveryAckDelay_get", (PyCFunction)_wrap_TransportLayerControl_gevDiscoveryAckDelay_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevIEEE1588_get", (PyCFunction)_wrap_TransportLayerControl_gevIEEE1588_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevIEEE1588ClockAccuracy_get", (PyCFunction)_wrap_TransportLayerControl_gevIEEE1588ClockAccuracy_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevIEEE1588Status_get", (PyCFunction)_wrap_TransportLayerControl_gevIEEE1588Status_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevGVCPExtendedStatusCodesSelector_get", (PyCFunction)_wrap_TransportLayerControl_gevGVCPExtendedStatusCodesSelector_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevGVCPExtendedStatusCodes_get", (PyCFunction)_wrap_TransportLayerControl_gevGVCPExtendedStatusCodes_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevGVCPPendingAck_get", (PyCFunction)_wrap_TransportLayerControl_gevGVCPPendingAck_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevGVCPHeartbeatDisable_get", (PyCFunction)_wrap_TransportLayerControl_gevGVCPHeartbeatDisable_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevGVCPPendingTimeout_get", (PyCFunction)_wrap_TransportLayerControl_gevGVCPPendingTimeout_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevPrimaryApplicationSwitchoverKey_get", (PyCFunction)_wrap_TransportLayerControl_gevPrimaryApplicationSwitchoverKey_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevGVSPExtendedIDMode_get", (PyCFunction)_wrap_TransportLayerControl_gevGVSPExtendedIDMode_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevCCP_get", (PyCFunction)_wrap_TransportLayerControl_gevCCP_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevPrimaryApplicationSocket_get", (PyCFunction)_wrap_TransportLayerControl_gevPrimaryApplicationSocket_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevPrimaryApplicationIPAddress_get", (PyCFunction)_wrap_TransportLayerControl_gevPrimaryApplicationIPAddress_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevMCPHostPort_get", (PyCFunction)_wrap_TransportLayerControl_gevMCPHostPort_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevMCDA_get", (PyCFunction)_wrap_TransportLayerControl_gevMCDA_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevMCTT_get", (PyCFunction)_wrap_TransportLayerControl_gevMCTT_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevMCRC_get", (PyCFunction)_wrap_TransportLayerControl_gevMCRC_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevMCSP_get", (PyCFunction)_wrap_TransportLayerControl_gevMCSP_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevStreamChannelSelector_get", (PyCFunction)_wrap_TransportLayerControl_gevStreamChannelSelector_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevSCCFGPacketResendDestination_get", (PyCFunction)_wrap_TransportLayerControl_gevSCCFGPacketResendDestination_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevSCCFGAllInTransmission_get", (PyCFunction)_wrap_TransportLayerControl_gevSCCFGAllInTransmission_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevSCCFGUnconditionalStreaming_get", (PyCFunction)_wrap_TransportLayerControl_gevSCCFGUnconditionalStreaming_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevSCCFGExtendedChunkData_get", (PyCFunction)_wrap_TransportLayerControl_gevSCCFGExtendedChunkData_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevSCPDirection_get", (PyCFunction)_wrap_TransportLayerControl_gevSCPDirection_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevSCPInterfaceIndex_get", (PyCFunction)_wrap_TransportLayerControl_gevSCPInterfaceIndex_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevSCPHostPort_get", (PyCFunction)_wrap_TransportLayerControl_gevSCPHostPort_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevSCPSFireTestPacket_get", (PyCFunction)_wrap_TransportLayerControl_gevSCPSFireTestPacket_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevSCPSDoNotFragment_get", (PyCFunction)_wrap_TransportLayerControl_gevSCPSDoNotFragment_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevSCPSBigEndian_get", (PyCFunction)_wrap_TransportLayerControl_gevSCPSBigEndian_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevSCPSPacketSize_get", (PyCFunction)_wrap_TransportLayerControl_gevSCPSPacketSize_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevSCPD_get", (PyCFunction)_wrap_TransportLayerControl_gevSCPD_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevSCDA_get", (PyCFunction)_wrap_TransportLayerControl_gevSCDA_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevSCSP_get", (PyCFunction)_wrap_TransportLayerControl_gevSCSP_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevSCZoneCount_get", (PyCFunction)_wrap_TransportLayerControl_gevSCZoneCount_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevSCZoneDirectionAll_get", (PyCFunction)_wrap_TransportLayerControl_gevSCZoneDirectionAll_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevSCZoneConfigurationLock_get", (PyCFunction)_wrap_TransportLayerControl_gevSCZoneConfigurationLock_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_aPAUSEMACCtrlFramesTransmitted_get", (PyCFunction)_wrap_TransportLayerControl_aPAUSEMACCtrlFramesTransmitted_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_aPAUSEMACCtrlFramesReceived_get", (PyCFunction)_wrap_TransportLayerControl_aPAUSEMACCtrlFramesReceived_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_clConfiguration_get", (PyCFunction)_wrap_TransportLayerControl_clConfiguration_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_clTimeSlotsCount_get", (PyCFunction)_wrap_TransportLayerControl_clTimeSlotsCount_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_cxpLinkConfigurationStatus_get", (PyCFunction)_wrap_TransportLayerControl_cxpLinkConfigurationStatus_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_cxpLinkConfigurationPreferred_get", (PyCFunction)_wrap_TransportLayerControl_cxpLinkConfigurationPreferred_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_cxpLinkConfiguration_get", (PyCFunction)_wrap_TransportLayerControl_cxpLinkConfiguration_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_cxpConnectionSelector_get", (PyCFunction)_wrap_TransportLayerControl_cxpConnectionSelector_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_cxpConnectionTestMode_get", (PyCFunction)_wrap_TransportLayerControl_cxpConnectionTestMode_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_cxpConnectionTestErrorCount_get", (PyCFunction)_wrap_TransportLayerControl_cxpConnectionTestErrorCount_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_cxpConnectionTestPacketCount_get", (PyCFunction)_wrap_TransportLayerControl_cxpConnectionTestPacketCount_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_cxpPoCxpAuto_get", (PyCFunction)_wrap_TransportLayerControl_cxpPoCxpAuto_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_cxpPoCxpTurnOff_get", (PyCFunction)_wrap_TransportLayerControl_cxpPoCxpTurnOff_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_cxpPoCxpTripReset_get", (PyCFunction)_wrap_TransportLayerControl_cxpPoCxpTripReset_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_cxpPoCxpStatus_get", (PyCFunction)_wrap_TransportLayerControl_cxpPoCxpStatus_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_mvGevSCBWControl_get", (PyCFunction)_wrap_TransportLayerControl_mvGevSCBWControl_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_mvGevSCBW_get", (PyCFunction)_wrap_TransportLayerControl_mvGevSCBW_get, METH_O, NULL},
	 { (char *)"TransportLayerControl_gevGetEffectivePayloadPacketsPerImage", _wrap_TransportLayerControl_gevGetEffectivePayloadPacketsPerImage, METH_VARARGS, NULL},
	 { (char *)"TransportLayerControl_gevGetEffectiveBytesPerImage", _wrap_TransportLayerControl_gevGetEffectiveBytesPerImage, METH_VARARGS, NULL},
	 { (char *)"TransportLayerControl_gevGetResultingBandwidth", _wrap_TransportLayerControl_gevGetResultingBandwidth, METH_VARARGS, NULL},
	 { (char *)"TransportLayerControl_gevGetResultingPacketDelay", _wrap_TransportLayerControl_gevGetResultingPacketDelay, METH_VARARGS, NULL},
	 { (char *)"delete_TransportLayerControl", (PyCFunction)_wrap_delete_TransportLayerControl, METH_O, NULL},
	 { (char *)"TransportLayerControl_swigregister", TransportLayerControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"TransportLayerControl_swiginit", TransportLayerControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_mvSerialInterfaceControl", _wrap_new_mvSerialInterfaceControl, METH_VARARGS, NULL},
	 { (char *)"mvSerialInterfaceControl_mvSerialInterfaceEnable_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvSerialInterfaceEnable_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvSerialInterfaceMode_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvSerialInterfaceMode_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvSerialInterfaceBaudRate_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvSerialInterfaceBaudRate_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvSerialInterfaceDataBits_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvSerialInterfaceDataBits_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvSerialInterfaceStopBits_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvSerialInterfaceStopBits_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvSerialInterfaceParity_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvSerialInterfaceParity_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvSerialInterfaceASCIIBuffer_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvSerialInterfaceASCIIBuffer_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvSerialInterfaceBinaryBuffer_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvSerialInterfaceBinaryBuffer_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvSerialInterfaceBytesToWrite_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvSerialInterfaceBytesToWrite_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvSerialInterfaceBytesAvailableForRead_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvSerialInterfaceBytesAvailableForRead_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvSerialInterfaceReceiveStatus_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvSerialInterfaceReceiveStatus_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvSerialInterfaceBytesToRead_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvSerialInterfaceBytesToRead_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvSerialInterfaceRead_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvSerialInterfaceRead_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvSerialInterfaceWrite_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvSerialInterfaceWrite_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvLiquidLensFirmwareVersion_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvLiquidLensFirmwareVersion_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvLiquidLensStatus_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvLiquidLensStatus_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvLiquidLensErrorCount_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvLiquidLensErrorCount_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvLiquidLensPowerMode_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvLiquidLensPowerMode_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvLiquidLensSetFocusValue_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvLiquidLensSetFocusValue_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvLiquidLensReceiveStatus_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvLiquidLensReceiveStatus_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvLiquidLensSaveFocusValue_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvLiquidLensSaveFocusValue_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvStepperFirmwareVersion_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvStepperFirmwareVersion_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvStepperReceiveStatus_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvStepperReceiveStatus_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvStepperErrorCount_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvStepperErrorCount_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvStepperAutoSavePositionEnable_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvStepperAutoSavePositionEnable_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvStepperMotorSelector_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvStepperMotorSelector_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvStepperStatus_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvStepperStatus_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvStepperCurrentPosition_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvStepperCurrentPosition_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvStepperDesiredPosition_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvStepperDesiredPosition_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvStepperSpeed_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvStepperSpeed_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvStepperAcceleration_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvStepperAcceleration_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvStepperSpeedManual_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvStepperSpeedManual_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvStepperPositionSetSelector_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvStepperPositionSetSelector_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvStepperPositionSetLoad_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvStepperPositionSetLoad_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvStepperPositionSetSave_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvStepperPositionSetSave_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvStepperMoveToHomeAll_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvStepperMoveToHomeAll_get, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_mvStepperStopAll_get", (PyCFunction)_wrap_mvSerialInterfaceControl_mvStepperStopAll_get, METH_O, NULL},
	 { (char *)"delete_mvSerialInterfaceControl", (PyCFunction)_wrap_delete_mvSerialInterfaceControl, METH_O, NULL},
	 { (char *)"mvSerialInterfaceControl_swigregister", mvSerialInterfaceControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"mvSerialInterfaceControl_swiginit", mvSerialInterfaceControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_mvI2cInterfaceControl", _wrap_new_mvI2cInterfaceControl, METH_VARARGS, NULL},
	 { (char *)"mvI2cInterfaceControl_mvI2cInterfaceDeviceAddress_get", (PyCFunction)_wrap_mvI2cInterfaceControl_mvI2cInterfaceDeviceAddress_get, METH_O, NULL},
	 { (char *)"mvI2cInterfaceControl_mvI2cInterfaceDeviceSubAddress_get", (PyCFunction)_wrap_mvI2cInterfaceControl_mvI2cInterfaceDeviceSubAddress_get, METH_O, NULL},
	 { (char *)"mvI2cInterfaceControl_mvI2cInterfaceASCIIBuffer_get", (PyCFunction)_wrap_mvI2cInterfaceControl_mvI2cInterfaceASCIIBuffer_get, METH_O, NULL},
	 { (char *)"mvI2cInterfaceControl_mvI2cInterfaceBinaryBuffer_get", (PyCFunction)_wrap_mvI2cInterfaceControl_mvI2cInterfaceBinaryBuffer_get, METH_O, NULL},
	 { (char *)"mvI2cInterfaceControl_mvI2cInterfaceBytesToWrite_get", (PyCFunction)_wrap_mvI2cInterfaceControl_mvI2cInterfaceBytesToWrite_get, METH_O, NULL},
	 { (char *)"mvI2cInterfaceControl_mvI2cInterfaceBytesToRead_get", (PyCFunction)_wrap_mvI2cInterfaceControl_mvI2cInterfaceBytesToRead_get, METH_O, NULL},
	 { (char *)"mvI2cInterfaceControl_mvI2cInterfaceRead_get", (PyCFunction)_wrap_mvI2cInterfaceControl_mvI2cInterfaceRead_get, METH_O, NULL},
	 { (char *)"mvI2cInterfaceControl_mvI2cInterfaceWrite_get", (PyCFunction)_wrap_mvI2cInterfaceControl_mvI2cInterfaceWrite_get, METH_O, NULL},
	 { (char *)"mvI2cInterfaceControl_mvI2cInterfaceSpeed_get", (PyCFunction)_wrap_mvI2cInterfaceControl_mvI2cInterfaceSpeed_get, METH_O, NULL},
	 { (char *)"delete_mvI2cInterfaceControl", (PyCFunction)_wrap_delete_mvI2cInterfaceControl, METH_O, NULL},
	 { (char *)"mvI2cInterfaceControl_swigregister", mvI2cInterfaceControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"mvI2cInterfaceControl_swiginit", mvI2cInterfaceControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_mvCustomData", _wrap_new_mvCustomData, METH_VARARGS, NULL},
	 { (char *)"mvCustomData_mvCustomText_get", (PyCFunction)_wrap_mvCustomData_mvCustomText_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvWriteCustomData_get", (PyCFunction)_wrap_mvCustomData_mvWriteCustomData_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvReadCustomData_get", (PyCFunction)_wrap_mvCustomData_mvReadCustomData_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvSensorRegister_get", (PyCFunction)_wrap_mvCustomData_mvSensorRegister_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvSensorRegisterValue_get", (PyCFunction)_wrap_mvCustomData_mvSensorRegisterValue_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvInternalRegister_get", (PyCFunction)_wrap_mvCustomData_mvInternalRegister_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvInternalRegisterValue_get", (PyCFunction)_wrap_mvCustomData_mvInternalRegisterValue_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvMSeqRegister_get", (PyCFunction)_wrap_mvCustomData_mvMSeqRegister_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvMSeqRegisterValue_get", (PyCFunction)_wrap_mvCustomData_mvMSeqRegisterValue_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvStateSumRegister_get", (PyCFunction)_wrap_mvCustomData_mvStateSumRegister_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvStat2SumRegister_get", (PyCFunction)_wrap_mvCustomData_mvStat2SumRegister_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvStateSumRegisterReset_get", (PyCFunction)_wrap_mvCustomData_mvStateSumRegisterReset_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvLVDSSelection_get", (PyCFunction)_wrap_mvCustomData_mvLVDSSelection_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvLVDSAlignment_get", (PyCFunction)_wrap_mvCustomData_mvLVDSAlignment_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvRunTest_get", (PyCFunction)_wrap_mvCustomData_mvRunTest_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvTestNumber_get", (PyCFunction)_wrap_mvCustomData_mvTestNumber_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvTestMin_get", (PyCFunction)_wrap_mvCustomData_mvTestMin_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvTestMax_get", (PyCFunction)_wrap_mvCustomData_mvTestMax_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvCustomCommandInterpreterVersionMajor_get", (PyCFunction)_wrap_mvCustomData_mvCustomCommandInterpreterVersionMajor_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvCustomCommandInterpreterVersionMinor_get", (PyCFunction)_wrap_mvCustomData_mvCustomCommandInterpreterVersionMinor_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvCustomCommandBuffer_get", (PyCFunction)_wrap_mvCustomData_mvCustomCommandBuffer_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvImxSensorType_get", (PyCFunction)_wrap_mvCustomData_mvImxSensorType_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvImxSensorIdOne_get", (PyCFunction)_wrap_mvCustomData_mvImxSensorIdOne_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvImxGroup_get", (PyCFunction)_wrap_mvCustomData_mvImxGroup_get, METH_O, NULL},
	 { (char *)"mvCustomData_mvImxSensorIdTwo_get", (PyCFunction)_wrap_mvCustomData_mvImxSensorIdTwo_get, METH_O, NULL},
	 { (char *)"delete_mvCustomData", (PyCFunction)_wrap_delete_mvCustomData, METH_O, NULL},
	 { (char *)"mvCustomData_swigregister", mvCustomData_swigregister, METH_VARARGS, NULL},
	 { (char *)"mvCustomData_swiginit", mvCustomData_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_mvLogicGateControl", _wrap_new_mvLogicGateControl, METH_VARARGS, NULL},
	 { (char *)"mvLogicGateControl_mvLogicGateANDSelector_get", (PyCFunction)_wrap_mvLogicGateControl_mvLogicGateANDSelector_get, METH_O, NULL},
	 { (char *)"mvLogicGateControl_mvLogicGateANDSource1_get", (PyCFunction)_wrap_mvLogicGateControl_mvLogicGateANDSource1_get, METH_O, NULL},
	 { (char *)"mvLogicGateControl_mvANDSource1Inverter_get", (PyCFunction)_wrap_mvLogicGateControl_mvANDSource1Inverter_get, METH_O, NULL},
	 { (char *)"mvLogicGateControl_mvLogicGateANDSource2_get", (PyCFunction)_wrap_mvLogicGateControl_mvLogicGateANDSource2_get, METH_O, NULL},
	 { (char *)"mvLogicGateControl_mvANDSource2Inverter_get", (PyCFunction)_wrap_mvLogicGateControl_mvANDSource2Inverter_get, METH_O, NULL},
	 { (char *)"mvLogicGateControl_mvLogicGateORSelector_get", (PyCFunction)_wrap_mvLogicGateControl_mvLogicGateORSelector_get, METH_O, NULL},
	 { (char *)"mvLogicGateControl_mvLogicGateORSource1_get", (PyCFunction)_wrap_mvLogicGateControl_mvLogicGateORSource1_get, METH_O, NULL},
	 { (char *)"mvLogicGateControl_mvLogicGateORSource2_get", (PyCFunction)_wrap_mvLogicGateControl_mvLogicGateORSource2_get, METH_O, NULL},
	 { (char *)"mvLogicGateControl_mvLogicGateORSource3_get", (PyCFunction)_wrap_mvLogicGateControl_mvLogicGateORSource3_get, METH_O, NULL},
	 { (char *)"mvLogicGateControl_mvLogicGateORSource4_get", (PyCFunction)_wrap_mvLogicGateControl_mvLogicGateORSource4_get, METH_O, NULL},
	 { (char *)"mvLogicGateControl_mvLogicGateSourceSelector_get", (PyCFunction)_wrap_mvLogicGateControl_mvLogicGateSourceSelector_get, METH_O, NULL},
	 { (char *)"mvLogicGateControl_mvLogicGateSource_get", (PyCFunction)_wrap_mvLogicGateControl_mvLogicGateSource_get, METH_O, NULL},
	 { (char *)"mvLogicGateControl_mvLogicGateSourceInverter_get", (PyCFunction)_wrap_mvLogicGateControl_mvLogicGateSourceInverter_get, METH_O, NULL},
	 { (char *)"mvLogicGateControl_mvLogicGateANDTermSelector_get", (PyCFunction)_wrap_mvLogicGateControl_mvLogicGateANDTermSelector_get, METH_O, NULL},
	 { (char *)"mvLogicGateControl_mvLogicGateANDTermSrc0_get", (PyCFunction)_wrap_mvLogicGateControl_mvLogicGateANDTermSrc0_get, METH_O, NULL},
	 { (char *)"mvLogicGateControl_mvLogicGateANDTermSrc1_get", (PyCFunction)_wrap_mvLogicGateControl_mvLogicGateANDTermSrc1_get, METH_O, NULL},
	 { (char *)"mvLogicGateControl_mvLogicGateORTermSelector_get", (PyCFunction)_wrap_mvLogicGateControl_mvLogicGateORTermSelector_get, METH_O, NULL},
	 { (char *)"mvLogicGateControl_mvLogicGateORTermSrc0_get", (PyCFunction)_wrap_mvLogicGateControl_mvLogicGateORTermSrc0_get, METH_O, NULL},
	 { (char *)"mvLogicGateControl_mvLogicGateORTermSrc1_get", (PyCFunction)_wrap_mvLogicGateControl_mvLogicGateORTermSrc1_get, METH_O, NULL},
	 { (char *)"delete_mvLogicGateControl", (PyCFunction)_wrap_delete_mvLogicGateControl, METH_O, NULL},
	 { (char *)"mvLogicGateControl_swigregister", mvLogicGateControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"mvLogicGateControl_swiginit", mvLogicGateControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_mvCurrentControl", _wrap_new_mvCurrentControl, METH_VARARGS, NULL},
	 { (char *)"mvCurrentControl_mvCurrentSelector_get", (PyCFunction)_wrap_mvCurrentControl_mvCurrentSelector_get, METH_O, NULL},
	 { (char *)"mvCurrentControl_mvCurrent_get", (PyCFunction)_wrap_mvCurrentControl_mvCurrent_get, METH_O, NULL},
	 { (char *)"delete_mvCurrentControl", (PyCFunction)_wrap_delete_mvCurrentControl, METH_O, NULL},
	 { (char *)"mvCurrentControl_swigregister", mvCurrentControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"mvCurrentControl_swiginit", mvCurrentControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_mvLensControl", _wrap_new_mvLensControl, METH_VARARGS, NULL},
	 { (char *)"mvLensControl_mvIrisType_get", (PyCFunction)_wrap_mvLensControl_mvIrisType_get, METH_O, NULL},
	 { (char *)"mvLensControl_mvIrisMode_get", (PyCFunction)_wrap_mvLensControl_mvIrisMode_get, METH_O, NULL},
	 { (char *)"mvLensControl_mvIrisSignalLevelMin_get", (PyCFunction)_wrap_mvLensControl_mvIrisSignalLevelMin_get, METH_O, NULL},
	 { (char *)"mvLensControl_mvIrisSignalLevelMax_get", (PyCFunction)_wrap_mvLensControl_mvIrisSignalLevelMax_get, METH_O, NULL},
	 { (char *)"mvLensControl_mvDriveSelector_get", (PyCFunction)_wrap_mvLensControl_mvDriveSelector_get, METH_O, NULL},
	 { (char *)"mvLensControl_mvDriveForward_get", (PyCFunction)_wrap_mvLensControl_mvDriveForward_get, METH_O, NULL},
	 { (char *)"mvLensControl_mvDriveBackward_get", (PyCFunction)_wrap_mvLensControl_mvDriveBackward_get, METH_O, NULL},
	 { (char *)"mvLensControl_mvDriveDuration_get", (PyCFunction)_wrap_mvLensControl_mvDriveDuration_get, METH_O, NULL},
	 { (char *)"mvLensControl_mvDriveLevel_get", (PyCFunction)_wrap_mvLensControl_mvDriveLevel_get, METH_O, NULL},
	 { (char *)"delete_mvLensControl", (PyCFunction)_wrap_delete_mvLensControl, METH_O, NULL},
	 { (char *)"mvLensControl_swigregister", mvLensControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"mvLensControl_swiginit", mvLensControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_mvFFCControl", _wrap_new_mvFFCControl, METH_VARARGS, NULL},
	 { (char *)"mvFFCControl_mvFFCEnable_get", (PyCFunction)_wrap_mvFFCControl_mvFFCEnable_get, METH_O, NULL},
	 { (char *)"mvFFCControl_mvFFCCalibrationImageCount_get", (PyCFunction)_wrap_mvFFCControl_mvFFCCalibrationImageCount_get, METH_O, NULL},
	 { (char *)"mvFFCControl_mvFFCCalibrate_get", (PyCFunction)_wrap_mvFFCControl_mvFFCCalibrate_get, METH_O, NULL},
	 { (char *)"mvFFCControl_mvFFCImageLoad_get", (PyCFunction)_wrap_mvFFCControl_mvFFCImageLoad_get, METH_O, NULL},
	 { (char *)"mvFFCControl_mvFFCImageSave_get", (PyCFunction)_wrap_mvFFCControl_mvFFCImageSave_get, METH_O, NULL},
	 { (char *)"mvFFCControl_mvFFCAutoLoadMode_get", (PyCFunction)_wrap_mvFFCControl_mvFFCAutoLoadMode_get, METH_O, NULL},
	 { (char *)"delete_mvFFCControl", (PyCFunction)_wrap_delete_mvFFCControl, METH_O, NULL},
	 { (char *)"mvFFCControl_swigregister", mvFFCControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"mvFFCControl_swiginit", mvFFCControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_mvFrameAverageControl", _wrap_new_mvFrameAverageControl, METH_VARARGS, NULL},
	 { (char *)"mvFrameAverageControl_mvFrameAverageMode_get", (PyCFunction)_wrap_mvFrameAverageControl_mvFrameAverageMode_get, METH_O, NULL},
	 { (char *)"mvFrameAverageControl_mvFrameAverageEnable_get", (PyCFunction)_wrap_mvFrameAverageControl_mvFrameAverageEnable_get, METH_O, NULL},
	 { (char *)"mvFrameAverageControl_mvFrameAverageSlope_get", (PyCFunction)_wrap_mvFrameAverageControl_mvFrameAverageSlope_get, METH_O, NULL},
	 { (char *)"mvFrameAverageControl_mvFrameAverageDynamicMode_get", (PyCFunction)_wrap_mvFrameAverageControl_mvFrameAverageDynamicMode_get, METH_O, NULL},
	 { (char *)"mvFrameAverageControl_mvFrameAverageNoiseLimit_get", (PyCFunction)_wrap_mvFrameAverageControl_mvFrameAverageNoiseLimit_get, METH_O, NULL},
	 { (char *)"mvFrameAverageControl_mvFrameAverageNoiseGain_get", (PyCFunction)_wrap_mvFrameAverageControl_mvFrameAverageNoiseGain_get, METH_O, NULL},
	 { (char *)"mvFrameAverageControl_mvFrameAverageFrameCount_get", (PyCFunction)_wrap_mvFrameAverageControl_mvFrameAverageFrameCount_get, METH_O, NULL},
	 { (char *)"delete_mvFrameAverageControl", (PyCFunction)_wrap_delete_mvFrameAverageControl, METH_O, NULL},
	 { (char *)"mvFrameAverageControl_swigregister", mvFrameAverageControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"mvFrameAverageControl_swiginit", mvFrameAverageControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_mvHDRControl", _wrap_new_mvHDRControl, METH_VARARGS, NULL},
	 { (char *)"mvHDRControl_mvHDREnable_get", (PyCFunction)_wrap_mvHDRControl_mvHDREnable_get, METH_O, NULL},
	 { (char *)"mvHDRControl_mvHDRPreset_get", (PyCFunction)_wrap_mvHDRControl_mvHDRPreset_get, METH_O, NULL},
	 { (char *)"mvHDRControl_mvHDRSelector_get", (PyCFunction)_wrap_mvHDRControl_mvHDRSelector_get, METH_O, NULL},
	 { (char *)"mvHDRControl_mvHDRVoltage1_get", (PyCFunction)_wrap_mvHDRControl_mvHDRVoltage1_get, METH_O, NULL},
	 { (char *)"mvHDRControl_mvHDRVoltage2_get", (PyCFunction)_wrap_mvHDRControl_mvHDRVoltage2_get, METH_O, NULL},
	 { (char *)"mvHDRControl_mvHDRExposure1_get", (PyCFunction)_wrap_mvHDRControl_mvHDRExposure1_get, METH_O, NULL},
	 { (char *)"mvHDRControl_mvHDRExposure2_get", (PyCFunction)_wrap_mvHDRControl_mvHDRExposure2_get, METH_O, NULL},
	 { (char *)"mvHDRControl_mvHDRExposureRatio_get", (PyCFunction)_wrap_mvHDRControl_mvHDRExposureRatio_get, METH_O, NULL},
	 { (char *)"mvHDRControl_mvHDRMotionCompensationEnable_get", (PyCFunction)_wrap_mvHDRControl_mvHDRMotionCompensationEnable_get, METH_O, NULL},
	 { (char *)"mvHDRControl_mvHDRAdaptiveLocalToneMappingEnable_get", (PyCFunction)_wrap_mvHDRControl_mvHDRAdaptiveLocalToneMappingEnable_get, METH_O, NULL},
	 { (char *)"delete_mvHDRControl", (PyCFunction)_wrap_delete_mvHDRControl, METH_O, NULL},
	 { (char *)"mvHDRControl_swigregister", mvHDRControl_swigregister, METH_VARARGS, NULL},
	 { (char *)"mvHDRControl_swiginit", mvHDRControl_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_SystemModule", _wrap_new_SystemModule, METH_VARARGS, NULL},
	 { (char *)"SystemModule_TLVendorName_get", (PyCFunction)_wrap_SystemModule_TLVendorName_get, METH_O, NULL},
	 { (char *)"SystemModule_TLModelName_get", (PyCFunction)_wrap_SystemModule_TLModelName_get, METH_O, NULL},
	 { (char *)"SystemModule_TLID_get", (PyCFunction)_wrap_SystemModule_TLID_get, METH_O, NULL},
	 { (char *)"SystemModule_TLVersion_get", (PyCFunction)_wrap_SystemModule_TLVersion_get, METH_O, NULL},
	 { (char *)"SystemModule_TLFileName_get", (PyCFunction)_wrap_SystemModule_TLFileName_get, METH_O, NULL},
	 { (char *)"SystemModule_TLDisplayName_get", (PyCFunction)_wrap_SystemModule_TLDisplayName_get, METH_O, NULL},
	 { (char *)"SystemModule_TLPath_get", (PyCFunction)_wrap_SystemModule_TLPath_get, METH_O, NULL},
	 { (char *)"SystemModule_TLType_get", (PyCFunction)_wrap_SystemModule_TLType_get, METH_O, NULL},
	 { (char *)"SystemModule_genTLVersionMajor_get", (PyCFunction)_wrap_SystemModule_genTLVersionMajor_get, METH_O, NULL},
	 { (char *)"SystemModule_genTLVersionMinor_get", (PyCFunction)_wrap_SystemModule_genTLVersionMinor_get, METH_O, NULL},
	 { (char *)"SystemModule_genTLSFNCVersionMajor_get", (PyCFunction)_wrap_SystemModule_genTLSFNCVersionMajor_get, METH_O, NULL},
	 { (char *)"SystemModule_genTLSFNCVersionMinor_get", (PyCFunction)_wrap_SystemModule_genTLSFNCVersionMinor_get, METH_O, NULL},
	 { (char *)"SystemModule_genTLSFNCVersionSubMinor_get", (PyCFunction)_wrap_SystemModule_genTLSFNCVersionSubMinor_get, METH_O, NULL},
	 { (char *)"SystemModule_genCPVersionMajor_get", (PyCFunction)_wrap_SystemModule_genCPVersionMajor_get, METH_O, NULL},
	 { (char *)"SystemModule_genCPVersionMinor_get", (PyCFunction)_wrap_SystemModule_genCPVersionMinor_get, METH_O, NULL},
	 { (char *)"SystemModule_gevVersionMajor_get", (PyCFunction)_wrap_SystemModule_gevVersionMajor_get, METH_O, NULL},
	 { (char *)"SystemModule_gevVersionMinor_get", (PyCFunction)_wrap_SystemModule_gevVersionMinor_get, METH_O, NULL},
	 { (char *)"SystemModule_u3vVersionMajor_get", (PyCFunction)_wrap_SystemModule_u3vVersionMajor_get, METH_O, NULL},
	 { (char *)"SystemModule_u3vVersionMinor_get", (PyCFunction)_wrap_SystemModule_u3vVersionMinor_get, METH_O, NULL},
	 { (char *)"SystemModule_mvGevChannelDummyPacketSendEnable_get", (PyCFunction)_wrap_SystemModule_mvGevChannelDummyPacketSendEnable_get, METH_O, NULL},
	 { (char *)"SystemModule_mvGevChannelDummyPacketSendInterval_get", (PyCFunction)_wrap_SystemModule_mvGevChannelDummyPacketSendInterval_get, METH_O, NULL},
	 { (char *)"SystemModule_mvInterfaceTechnologyToIgnoreSelector_get", (PyCFunction)_wrap_SystemModule_mvInterfaceTechnologyToIgnoreSelector_get, METH_O, NULL},
	 { (char *)"SystemModule_mvInterfaceTechnologyToIgnoreEnable_get", (PyCFunction)_wrap_SystemModule_mvInterfaceTechnologyToIgnoreEnable_get, METH_O, NULL},
	 { (char *)"SystemModule_interfaceUpdateList_get", (PyCFunction)_wrap_SystemModule_interfaceUpdateList_get, METH_O, NULL},
	 { (char *)"SystemModule_interfaceUpdateTimeout_get", (PyCFunction)_wrap_SystemModule_interfaceUpdateTimeout_get, METH_O, NULL},
	 { (char *)"SystemModule_interfaceSelector_get", (PyCFunction)_wrap_SystemModule_interfaceSelector_get, METH_O, NULL},
	 { (char *)"SystemModule_interfaceID_get", (PyCFunction)_wrap_SystemModule_interfaceID_get, METH_O, NULL},
	 { (char *)"SystemModule_interfaceDisplayName_get", (PyCFunction)_wrap_SystemModule_interfaceDisplayName_get, METH_O, NULL},
	 { (char *)"SystemModule_interfaceType_get", (PyCFunction)_wrap_SystemModule_interfaceType_get, METH_O, NULL},
	 { (char *)"SystemModule_gevInterfaceMACAddress_get", (PyCFunction)_wrap_SystemModule_gevInterfaceMACAddress_get, METH_O, NULL},
	 { (char *)"SystemModule_gevInterfaceDefaultIPAddress_get", (PyCFunction)_wrap_SystemModule_gevInterfaceDefaultIPAddress_get, METH_O, NULL},
	 { (char *)"SystemModule_gevInterfaceDefaultSubnetMask_get", (PyCFunction)_wrap_SystemModule_gevInterfaceDefaultSubnetMask_get, METH_O, NULL},
	 { (char *)"SystemModule_gevInterfaceDefaultGateway_get", (PyCFunction)_wrap_SystemModule_gevInterfaceDefaultGateway_get, METH_O, NULL},
	 { (char *)"SystemModule_mvGevInterfaceMTU_get", (PyCFunction)_wrap_SystemModule_mvGevInterfaceMTU_get, METH_O, NULL},
	 { (char *)"SystemModule_mvGevInterfaceLinkSpeed_get", (PyCFunction)_wrap_SystemModule_mvGevInterfaceLinkSpeed_get, METH_O, NULL},
	 { (char *)"SystemModule_mvDeviceUpdateListBehaviour_get", (PyCFunction)_wrap_SystemModule_mvDeviceUpdateListBehaviour_get, METH_O, NULL},
	 { (char *)"SystemModule_eventSelector_get", (PyCFunction)_wrap_SystemModule_eventSelector_get, METH_O, NULL},
	 { (char *)"SystemModule_eventNotification_get", (PyCFunction)_wrap_SystemModule_eventNotification_get, METH_O, NULL},
	 { (char *)"delete_SystemModule", (PyCFunction)_wrap_delete_SystemModule, METH_O, NULL},
	 { (char *)"SystemModule_swigregister", SystemModule_swigregister, METH_VARARGS, NULL},
	 { (char *)"SystemModule_swiginit", SystemModule_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_InterfaceModule", _wrap_new_InterfaceModule, METH_VARARGS, NULL},
	 { (char *)"InterfaceModule_interfaceID_get", (PyCFunction)_wrap_InterfaceModule_interfaceID_get, METH_O, NULL},
	 { (char *)"InterfaceModule_interfaceDisplayName_get", (PyCFunction)_wrap_InterfaceModule_interfaceDisplayName_get, METH_O, NULL},
	 { (char *)"InterfaceModule_interfaceType_get", (PyCFunction)_wrap_InterfaceModule_interfaceType_get, METH_O, NULL},
	 { (char *)"InterfaceModule_interfaceTLVersionMajor_get", (PyCFunction)_wrap_InterfaceModule_interfaceTLVersionMajor_get, METH_O, NULL},
	 { (char *)"InterfaceModule_interfaceTLVersionMinor_get", (PyCFunction)_wrap_InterfaceModule_interfaceTLVersionMinor_get, METH_O, NULL},
	 { (char *)"InterfaceModule_gevInterfaceGatewaySelector_get", (PyCFunction)_wrap_InterfaceModule_gevInterfaceGatewaySelector_get, METH_O, NULL},
	 { (char *)"InterfaceModule_gevInterfaceGateway_get", (PyCFunction)_wrap_InterfaceModule_gevInterfaceGateway_get, METH_O, NULL},
	 { (char *)"InterfaceModule_gevInterfaceMACAddress_get", (PyCFunction)_wrap_InterfaceModule_gevInterfaceMACAddress_get, METH_O, NULL},
	 { (char *)"InterfaceModule_gevInterfaceSubnetSelector_get", (PyCFunction)_wrap_InterfaceModule_gevInterfaceSubnetSelector_get, METH_O, NULL},
	 { (char *)"InterfaceModule_gevInterfaceSubnetIPAddress_get", (PyCFunction)_wrap_InterfaceModule_gevInterfaceSubnetIPAddress_get, METH_O, NULL},
	 { (char *)"InterfaceModule_gevInterfaceSubnetMask_get", (PyCFunction)_wrap_InterfaceModule_gevInterfaceSubnetMask_get, METH_O, NULL},
	 { (char *)"InterfaceModule_mvGevInterfaceMTU_get", (PyCFunction)_wrap_InterfaceModule_mvGevInterfaceMTU_get, METH_O, NULL},
	 { (char *)"InterfaceModule_mvGevInterfaceLinkSpeed_get", (PyCFunction)_wrap_InterfaceModule_mvGevInterfaceLinkSpeed_get, METH_O, NULL},
	 { (char *)"InterfaceModule_mvGevAdvancedDeviceDiscoveryEnable_get", (PyCFunction)_wrap_InterfaceModule_mvGevAdvancedDeviceDiscoveryEnable_get, METH_O, NULL},
	 { (char *)"InterfaceModule_deviceUpdateList_get", (PyCFunction)_wrap_InterfaceModule_deviceUpdateList_get, METH_O, NULL},
	 { (char *)"InterfaceModule_deviceUpdateTimeout_get", (PyCFunction)_wrap_InterfaceModule_deviceUpdateTimeout_get, METH_O, NULL},
	 { (char *)"InterfaceModule_deviceSelector_get", (PyCFunction)_wrap_InterfaceModule_deviceSelector_get, METH_O, NULL},
	 { (char *)"InterfaceModule_deviceID_get", (PyCFunction)_wrap_InterfaceModule_deviceID_get, METH_O, NULL},
	 { (char *)"InterfaceModule_deviceVendorName_get", (PyCFunction)_wrap_InterfaceModule_deviceVendorName_get, METH_O, NULL},
	 { (char *)"InterfaceModule_deviceModelName_get", (PyCFunction)_wrap_InterfaceModule_deviceModelName_get, METH_O, NULL},
	 { (char *)"InterfaceModule_deviceType_get", (PyCFunction)_wrap_InterfaceModule_deviceType_get, METH_O, NULL},
	 { (char *)"InterfaceModule_deviceLinkSpeed_get", (PyCFunction)_wrap_InterfaceModule_deviceLinkSpeed_get, METH_O, NULL},
	 { (char *)"InterfaceModule_deviceAccessStatus_get", (PyCFunction)_wrap_InterfaceModule_deviceAccessStatus_get, METH_O, NULL},
	 { (char *)"InterfaceModule_deviceSerialNumber_get", (PyCFunction)_wrap_InterfaceModule_deviceSerialNumber_get, METH_O, NULL},
	 { (char *)"InterfaceModule_deviceUserID_get", (PyCFunction)_wrap_InterfaceModule_deviceUserID_get, METH_O, NULL},
	 { (char *)"InterfaceModule_deviceTLVersionMajor_get", (PyCFunction)_wrap_InterfaceModule_deviceTLVersionMajor_get, METH_O, NULL},
	 { (char *)"InterfaceModule_deviceTLVersionMinor_get", (PyCFunction)_wrap_InterfaceModule_deviceTLVersionMinor_get, METH_O, NULL},
	 { (char *)"InterfaceModule_gevDeviceIPAddress_get", (PyCFunction)_wrap_InterfaceModule_gevDeviceIPAddress_get, METH_O, NULL},
	 { (char *)"InterfaceModule_gevDeviceSubnetMask_get", (PyCFunction)_wrap_InterfaceModule_gevDeviceSubnetMask_get, METH_O, NULL},
	 { (char *)"InterfaceModule_gevDeviceGateway_get", (PyCFunction)_wrap_InterfaceModule_gevDeviceGateway_get, METH_O, NULL},
	 { (char *)"InterfaceModule_gevDeviceIPConfigurationStatus_get", (PyCFunction)_wrap_InterfaceModule_gevDeviceIPConfigurationStatus_get, METH_O, NULL},
	 { (char *)"InterfaceModule_gevDeviceMACAddress_get", (PyCFunction)_wrap_InterfaceModule_gevDeviceMACAddress_get, METH_O, NULL},
	 { (char *)"InterfaceModule_gevCurrentControlMode_get", (PyCFunction)_wrap_InterfaceModule_gevCurrentControlMode_get, METH_O, NULL},
	 { (char *)"InterfaceModule_mvDeviceCommandChannelTransmissionTimeout_get", (PyCFunction)_wrap_InterfaceModule_mvDeviceCommandChannelTransmissionTimeout_get, METH_O, NULL},
	 { (char *)"InterfaceModule_mvDeviceCommandChannelRetryCount_get", (PyCFunction)_wrap_InterfaceModule_mvDeviceCommandChannelRetryCount_get, METH_O, NULL},
	 { (char *)"InterfaceModule_gevVersionMajor_get", (PyCFunction)_wrap_InterfaceModule_gevVersionMajor_get, METH_O, NULL},
	 { (char *)"InterfaceModule_gevVersionMinor_get", (PyCFunction)_wrap_InterfaceModule_gevVersionMinor_get, METH_O, NULL},
	 { (char *)"InterfaceModule_genCPVersionMajor_get", (PyCFunction)_wrap_InterfaceModule_genCPVersionMajor_get, METH_O, NULL},
	 { (char *)"InterfaceModule_genCPVersionMinor_get", (PyCFunction)_wrap_InterfaceModule_genCPVersionMinor_get, METH_O, NULL},
	 { (char *)"InterfaceModule_u3vVersionMajor_get", (PyCFunction)_wrap_InterfaceModule_u3vVersionMajor_get, METH_O, NULL},
	 { (char *)"InterfaceModule_u3vVersionMinor_get", (PyCFunction)_wrap_InterfaceModule_u3vVersionMinor_get, METH_O, NULL},
	 { (char *)"InterfaceModule_mvDevicePrimaryApplicationSwitchoverSupported_get", (PyCFunction)_wrap_InterfaceModule_mvDevicePrimaryApplicationSwitchoverSupported_get, METH_O, NULL},
	 { (char *)"InterfaceModule_mvDevicePrimaryApplicationSwitchoverEnable_get", (PyCFunction)_wrap_InterfaceModule_mvDevicePrimaryApplicationSwitchoverEnable_get, METH_O, NULL},
	 { (char *)"InterfaceModule_gevApplicationSwitchoverKey_get", (PyCFunction)_wrap_InterfaceModule_gevApplicationSwitchoverKey_get, METH_O, NULL},
	 { (char *)"InterfaceModule_mvDeviceNetworkInterfaceCount_get", (PyCFunction)_wrap_InterfaceModule_mvDeviceNetworkInterfaceCount_get, METH_O, NULL},
	 { (char *)"InterfaceModule_gevDeviceForceIP_get", (PyCFunction)_wrap_InterfaceModule_gevDeviceForceIP_get, METH_O, NULL},
	 { (char *)"InterfaceModule_gevDeviceForceIPAddress_get", (PyCFunction)_wrap_InterfaceModule_gevDeviceForceIPAddress_get, METH_O, NULL},
	 { (char *)"InterfaceModule_gevDeviceForceSubnetMask_get", (PyCFunction)_wrap_InterfaceModule_gevDeviceForceSubnetMask_get, METH_O, NULL},
	 { (char *)"InterfaceModule_gevDeviceForceGateway_get", (PyCFunction)_wrap_InterfaceModule_gevDeviceForceGateway_get, METH_O, NULL},
	 { (char *)"InterfaceModule_actionCommand_get", (PyCFunction)_wrap_InterfaceModule_actionCommand_get, METH_O, NULL},
	 { (char *)"InterfaceModule_actionDeviceKey_get", (PyCFunction)_wrap_InterfaceModule_actionDeviceKey_get, METH_O, NULL},
	 { (char *)"InterfaceModule_actionGroupKey_get", (PyCFunction)_wrap_InterfaceModule_actionGroupKey_get, METH_O, NULL},
	 { (char *)"InterfaceModule_actionGroupMask_get", (PyCFunction)_wrap_InterfaceModule_actionGroupMask_get, METH_O, NULL},
	 { (char *)"InterfaceModule_actionScheduledTimeEnable_get", (PyCFunction)_wrap_InterfaceModule_actionScheduledTimeEnable_get, METH_O, NULL},
	 { (char *)"InterfaceModule_actionScheduledTime_get", (PyCFunction)_wrap_InterfaceModule_actionScheduledTime_get, METH_O, NULL},
	 { (char *)"InterfaceModule_gevActionDestinationIPAddress_get", (PyCFunction)_wrap_InterfaceModule_gevActionDestinationIPAddress_get, METH_O, NULL},
	 { (char *)"InterfaceModule_eventSelector_get", (PyCFunction)_wrap_InterfaceModule_eventSelector_get, METH_O, NULL},
	 { (char *)"InterfaceModule_eventNotification_get", (PyCFunction)_wrap_InterfaceModule_eventNotification_get, METH_O, NULL},
	 { (char *)"delete_InterfaceModule", (PyCFunction)_wrap_delete_InterfaceModule, METH_O, NULL},
	 { (char *)"InterfaceModule_swigregister", InterfaceModule_swigregister, METH_VARARGS, NULL},
	 { (char *)"InterfaceModule_swiginit", InterfaceModule_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_DeviceModule", _wrap_new_DeviceModule, METH_VARARGS, NULL},
	 { (char *)"DeviceModule_deviceID_get", (PyCFunction)_wrap_DeviceModule_deviceID_get, METH_O, NULL},
	 { (char *)"DeviceModule_deviceSerialNumber_get", (PyCFunction)_wrap_DeviceModule_deviceSerialNumber_get, METH_O, NULL},
	 { (char *)"DeviceModule_deviceUserID_get", (PyCFunction)_wrap_DeviceModule_deviceUserID_get, METH_O, NULL},
	 { (char *)"DeviceModule_deviceVendorName_get", (PyCFunction)_wrap_DeviceModule_deviceVendorName_get, METH_O, NULL},
	 { (char *)"DeviceModule_deviceModelName_get", (PyCFunction)_wrap_DeviceModule_deviceModelName_get, METH_O, NULL},
	 { (char *)"DeviceModule_deviceFamilyName_get", (PyCFunction)_wrap_DeviceModule_deviceFamilyName_get, METH_O, NULL},
	 { (char *)"DeviceModule_deviceVersion_get", (PyCFunction)_wrap_DeviceModule_deviceVersion_get, METH_O, NULL},
	 { (char *)"DeviceModule_deviceManufacturerInfo_get", (PyCFunction)_wrap_DeviceModule_deviceManufacturerInfo_get, METH_O, NULL},
	 { (char *)"DeviceModule_deviceType_get", (PyCFunction)_wrap_DeviceModule_deviceType_get, METH_O, NULL},
	 { (char *)"DeviceModule_deviceDisplayName_get", (PyCFunction)_wrap_DeviceModule_deviceDisplayName_get, METH_O, NULL},
	 { (char *)"DeviceModule_deviceTimestampFrequency_get", (PyCFunction)_wrap_DeviceModule_deviceTimestampFrequency_get, METH_O, NULL},
	 { (char *)"DeviceModule_deviceAccessStatus_get", (PyCFunction)_wrap_DeviceModule_deviceAccessStatus_get, METH_O, NULL},
	 { (char *)"DeviceModule_deviceChunkDataFormat_get", (PyCFunction)_wrap_DeviceModule_deviceChunkDataFormat_get, METH_O, NULL},
	 { (char *)"DeviceModule_deviceEventDataFormat_get", (PyCFunction)_wrap_DeviceModule_deviceEventDataFormat_get, METH_O, NULL},
	 { (char *)"DeviceModule_gevDeviceMACAddress_get", (PyCFunction)_wrap_DeviceModule_gevDeviceMACAddress_get, METH_O, NULL},
	 { (char *)"DeviceModule_gevDeviceIPAddress_get", (PyCFunction)_wrap_DeviceModule_gevDeviceIPAddress_get, METH_O, NULL},
	 { (char *)"DeviceModule_gevDeviceSubnetMask_get", (PyCFunction)_wrap_DeviceModule_gevDeviceSubnetMask_get, METH_O, NULL},
	 { (char *)"DeviceModule_gevDeviceGateway_get", (PyCFunction)_wrap_DeviceModule_gevDeviceGateway_get, METH_O, NULL},
	 { (char *)"DeviceModule_gevVersionMajor_get", (PyCFunction)_wrap_DeviceModule_gevVersionMajor_get, METH_O, NULL},
	 { (char *)"DeviceModule_gevVersionMinor_get", (PyCFunction)_wrap_DeviceModule_gevVersionMinor_get, METH_O, NULL},
	 { (char *)"DeviceModule_genCPVersionMajor_get", (PyCFunction)_wrap_DeviceModule_genCPVersionMajor_get, METH_O, NULL},
	 { (char *)"DeviceModule_genCPVersionMinor_get", (PyCFunction)_wrap_DeviceModule_genCPVersionMinor_get, METH_O, NULL},
	 { (char *)"DeviceModule_u3vVersionMajor_get", (PyCFunction)_wrap_DeviceModule_u3vVersionMajor_get, METH_O, NULL},
	 { (char *)"DeviceModule_u3vVersionMinor_get", (PyCFunction)_wrap_DeviceModule_u3vVersionMinor_get, METH_O, NULL},
	 { (char *)"DeviceModule_deviceEndianessMechanism_get", (PyCFunction)_wrap_DeviceModule_deviceEndianessMechanism_get, METH_O, NULL},
	 { (char *)"DeviceModule_linkCommandTimeout_get", (PyCFunction)_wrap_DeviceModule_linkCommandTimeout_get, METH_O, NULL},
	 { (char *)"DeviceModule_linkCommandRetryCount_get", (PyCFunction)_wrap_DeviceModule_linkCommandRetryCount_get, METH_O, NULL},
	 { (char *)"DeviceModule_streamSelector_get", (PyCFunction)_wrap_DeviceModule_streamSelector_get, METH_O, NULL},
	 { (char *)"DeviceModule_streamID_get", (PyCFunction)_wrap_DeviceModule_streamID_get, METH_O, NULL},
	 { (char *)"DeviceModule_eventSelector_get", (PyCFunction)_wrap_DeviceModule_eventSelector_get, METH_O, NULL},
	 { (char *)"DeviceModule_eventNotification_get", (PyCFunction)_wrap_DeviceModule_eventNotification_get, METH_O, NULL},
	 { (char *)"delete_DeviceModule", (PyCFunction)_wrap_delete_DeviceModule, METH_O, NULL},
	 { (char *)"DeviceModule_swigregister", DeviceModule_swigregister, METH_VARARGS, NULL},
	 { (char *)"DeviceModule_swiginit", DeviceModule_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_DataStreamModule", _wrap_new_DataStreamModule, METH_VARARGS, NULL},
	 { (char *)"DataStreamModule_streamID_get", (PyCFunction)_wrap_DataStreamModule_streamID_get, METH_O, NULL},
	 { (char *)"DataStreamModule_streamType_get", (PyCFunction)_wrap_DataStreamModule_streamType_get, METH_O, NULL},
	 { (char *)"DataStreamModule_mvStreamDriverTechnology_get", (PyCFunction)_wrap_DataStreamModule_mvStreamDriverTechnology_get, METH_O, NULL},
	 { (char *)"DataStreamModule_mvAutoJoinMulticastGroups_get", (PyCFunction)_wrap_DataStreamModule_mvAutoJoinMulticastGroups_get, METH_O, NULL},
	 { (char *)"DataStreamModule_mvResendActive_get", (PyCFunction)_wrap_DataStreamModule_mvResendActive_get, METH_O, NULL},
	 { (char *)"DataStreamModule_mvResendMode_get", (PyCFunction)_wrap_DataStreamModule_mvResendMode_get, METH_O, NULL},
	 { (char *)"DataStreamModule_mvResendBatchingActive_get", (PyCFunction)_wrap_DataStreamModule_mvResendBatchingActive_get, METH_O, NULL},
	 { (char *)"DataStreamModule_mvResendCaptureWindowSize_get", (PyCFunction)_wrap_DataStreamModule_mvResendCaptureWindowSize_get, METH_O, NULL},
	 { (char *)"DataStreamModule_mvResendThreshold_get", (PyCFunction)_wrap_DataStreamModule_mvResendThreshold_get, METH_O, NULL},
	 { (char *)"DataStreamModule_mvResendRequestMax_get", (PyCFunction)_wrap_DataStreamModule_mvResendRequestMax_get, METH_O, NULL},
	 { (char *)"DataStreamModule_mvResendRequestCredits_get", (PyCFunction)_wrap_DataStreamModule_mvResendRequestCredits_get, METH_O, NULL},
	 { (char *)"DataStreamModule_mvResendResponseTimeout_get", (PyCFunction)_wrap_DataStreamModule_mvResendResponseTimeout_get, METH_O, NULL},
	 { (char *)"DataStreamModule_mvResendsPerTimeout_get", (PyCFunction)_wrap_DataStreamModule_mvResendsPerTimeout_get, METH_O, NULL},
	 { (char *)"DataStreamModule_mvResendFeaturesLocked_get", (PyCFunction)_wrap_DataStreamModule_mvResendFeaturesLocked_get, METH_O, NULL},
	 { (char *)"DataStreamModule_streamAnnouncedBufferCount_get", (PyCFunction)_wrap_DataStreamModule_streamAnnouncedBufferCount_get, METH_O, NULL},
	 { (char *)"DataStreamModule_streamBufferHandlingMode_get", (PyCFunction)_wrap_DataStreamModule_streamBufferHandlingMode_get, METH_O, NULL},
	 { (char *)"DataStreamModule_streamAnnounceBufferMinimum_get", (PyCFunction)_wrap_DataStreamModule_streamAnnounceBufferMinimum_get, METH_O, NULL},
	 { (char *)"DataStreamModule_mvStreamAnnounceBufferMaximum_get", (PyCFunction)_wrap_DataStreamModule_mvStreamAnnounceBufferMaximum_get, METH_O, NULL},
	 { (char *)"DataStreamModule_streamDeliveredFrameCount_get", (PyCFunction)_wrap_DataStreamModule_streamDeliveredFrameCount_get, METH_O, NULL},
	 { (char *)"DataStreamModule_streamLostFrameCount_get", (PyCFunction)_wrap_DataStreamModule_streamLostFrameCount_get, METH_O, NULL},
	 { (char *)"DataStreamModule_streamInputBufferCount_get", (PyCFunction)_wrap_DataStreamModule_streamInputBufferCount_get, METH_O, NULL},
	 { (char *)"DataStreamModule_streamOutputBufferCount_get", (PyCFunction)_wrap_DataStreamModule_streamOutputBufferCount_get, METH_O, NULL},
	 { (char *)"DataStreamModule_streamStartedFrameCount_get", (PyCFunction)_wrap_DataStreamModule_streamStartedFrameCount_get, METH_O, NULL},
	 { (char *)"DataStreamModule_payloadSize_get", (PyCFunction)_wrap_DataStreamModule_payloadSize_get, METH_O, NULL},
	 { (char *)"DataStreamModule_streamIsGrabbing_get", (PyCFunction)_wrap_DataStreamModule_streamIsGrabbing_get, METH_O, NULL},
	 { (char *)"DataStreamModule_streamChunkCountMaximum_get", (PyCFunction)_wrap_DataStreamModule_streamChunkCountMaximum_get, METH_O, NULL},
	 { (char *)"DataStreamModule_streamBufferAlignment_get", (PyCFunction)_wrap_DataStreamModule_streamBufferAlignment_get, METH_O, NULL},
	 { (char *)"DataStreamModule_eventSelector_get", (PyCFunction)_wrap_DataStreamModule_eventSelector_get, METH_O, NULL},
	 { (char *)"DataStreamModule_eventNotification_get", (PyCFunction)_wrap_DataStreamModule_eventNotification_get, METH_O, NULL},
	 { (char *)"delete_DataStreamModule", (PyCFunction)_wrap_delete_DataStreamModule, METH_O, NULL},
	 { (char *)"DataStreamModule_swigregister", DataStreamModule_swigregister, METH_VARARGS, NULL},
	 { (char *)"DataStreamModule_swiginit", DataStreamModule_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_CustomCommandGenerator", _wrap_new_CustomCommandGenerator, METH_VARARGS, NULL},
	 { (char *)"CustomCommandGenerator_discardCommandBuffer", (PyCFunction)_wrap_CustomCommandGenerator_discardCommandBuffer, METH_O, NULL},
	 { (char *)"CustomCommandGenerator_queueTransmissionRequest", _wrap_CustomCommandGenerator_queueTransmissionRequest, METH_VARARGS, NULL},
	 { (char *)"CustomCommandGenerator_requestTransmission", _wrap_CustomCommandGenerator_requestTransmission, METH_VARARGS, NULL},
	 { (char *)"CustomCommandGenerator_modifySequencerSetValue", _wrap_CustomCommandGenerator_modifySequencerSetValue, METH_VARARGS, NULL},
	 { (char *)"CustomCommandGenerator_queueSequencerSetValueModification", _wrap_CustomCommandGenerator_queueSequencerSetValueModification, METH_VARARGS, NULL},
	 { (char *)"CustomCommandGenerator_sendCommandBuffer", (PyCFunction)_wrap_CustomCommandGenerator_sendCommandBuffer, METH_O, NULL},
	 { (char *)"CustomCommandGenerator_commandBufferSize", (PyCFunction)_wrap_CustomCommandGenerator_commandBufferSize, METH_O, NULL},
	 { (char *)"CustomCommandGenerator_commandBufferSizeUsed", (PyCFunction)_wrap_CustomCommandGenerator_commandBufferSizeUsed, METH_O, NULL},
	 { (char *)"delete_CustomCommandGenerator", (PyCFunction)_wrap_delete_CustomCommandGenerator, METH_O, NULL},
	 { (char *)"CustomCommandGenerator_swigregister", CustomCommandGenerator_swigregister, METH_VARARGS, NULL},
	 { (char *)"CustomCommandGenerator_swiginit", CustomCommandGenerator_swiginit, METH_VARARGS, NULL},
	 { (char *)"new_FileProtocolAdapter", (PyCFunction)_wrap_new_FileProtocolAdapter, METH_NOARGS, NULL},
	 { (char *)"FileProtocolAdapter_attach", _wrap_FileProtocolAdapter_attach, METH_VARARGS, NULL},
	 { (char *)"FileProtocolAdapter_openFile", _wrap_FileProtocolAdapter_openFile, METH_VARARGS, NULL},
	 { (char *)"FileProtocolAdapter_closeFile", _wrap_FileProtocolAdapter_closeFile, METH_VARARGS, NULL},
	 { (char *)"FileProtocolAdapter_write", _wrap_FileProtocolAdapter_write, METH_VARARGS, NULL},
	 { (char *)"FileProtocolAdapter_read", _wrap_FileProtocolAdapter_read, METH_VARARGS, NULL},
	 { (char *)"FileProtocolAdapter_getBufSize", _wrap_FileProtocolAdapter_getBufSize, METH_VARARGS, NULL},
	 { (char *)"FileProtocolAdapter_size", (PyCFunction)_wrap_FileProtocolAdapter_size, METH_O, NULL},
	 { (char *)"delete_FileProtocolAdapter", (PyCFunction)_wrap_delete_FileProtocolAdapter, METH_O, NULL},
	 { (char *)"FileProtocolAdapter_swigregister", FileProtocolAdapter_swigregister, METH_VARARGS, NULL},
	 { (char *)"FileProtocolAdapter_swiginit", FileProtocolAdapter_swiginit, METH_VARARGS, NULL},
	 { NULL, NULL, 0, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

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__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__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__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__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__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__IOSubSystemCommonTo_p_mvIMPACT__acquire__IOSubSystem(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::IOSubSystem *)  ((mvIMPACT::acquire::IOSubSystemCommon *) x));
}
static void *_p_mvIMPACT__acquire__IOSubSystemBlueCOUGARTo_p_mvIMPACT__acquire__IOSubSystem(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::IOSubSystem *) (mvIMPACT::acquire::IOSubSystemCommon *) ((mvIMPACT::acquire::IOSubSystemBlueCOUGAR *) 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__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__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__GenICam__mvCustomDataTo_p_mvIMPACT__acquire__ComponentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentCollection *)  ((mvIMPACT::acquire::GenICam::mvCustomData *) 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__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__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__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__IOSubSystemBlueCOUGARTo_p_mvIMPACT__acquire__IOSubSystemCommon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::IOSubSystemCommon *)  ((mvIMPACT::acquire::IOSubSystemBlueCOUGAR *) 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__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__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__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_int64_t_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI64< int64_t > *) 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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__TThreadPriority_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TThreadPriority > *) 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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__TBufferPartDataType_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBufferPartDataType > *) 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__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__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__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__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__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__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__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__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__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__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__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__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__TDeviceEventMode_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceEventMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_tTo_p_mvIMPACT__acquire__Property(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Property *)  ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceEventType > *) 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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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_int64_t_tTo_p_mvIMPACT__acquire__ComponentAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::ComponentAccess *) (mvIMPACT::acquire::Component *)(mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI64< int64_t > *) 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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__TThreadPriority_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::TThreadPriority > *) 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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__TBufferPartDataType_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::TBufferPartDataType > *) 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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__TDeviceEventMode_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::TDeviceEventMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_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::TDeviceEventType > *) 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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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 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__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__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__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_int64_t_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI64< int64_t > *) 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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__TThreadPriority_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TThreadPriority > *) 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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__TBufferPartDataType_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBufferPartDataType > *) 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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__TDeviceEventMode_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceEventMode > *) x));
}
static void *_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_tTo_p_mvIMPACT__acquire__Component(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((mvIMPACT::acquire::Component *) (mvIMPACT::acquire::Property *) ((mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceEventType > *) 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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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 swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_double = {"_p_double", "double *", 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 *", 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_int64_t = {"_p_int64_t", "mvIMPACT::acquire::int64_type *|int64_t *", 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::ComponentIterator *|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_int64_t_t = {"_p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t", "mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type > *|mvIMPACT::acquire::EnumPropertyI64< int64_t > *|mvIMPACT::acquire::PropertyI64 *", 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__TBufferPartDataType_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBufferPartDataType_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TBufferPartDataType > *|mvIMPACT::acquire::PropertyI64BufferPartDataType *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBufferPartDataType > *", 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__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__TDeviceEventMode_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceEventMode > *|mvIMPACT::acquire::PropertyIDeviceEventMode *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventMode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t", "mvIMPACT::acquire::PropertyIDeviceEventType *|mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TDeviceEventType > *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceEventType > *", 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__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__TThreadPriority_t = {"_p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_t", "mvIMPACT::acquire::EnumPropertyI< enum mvIMPACT::acquire::TThreadPriority > *|mvIMPACT::acquire::PropertyIThreadPriority *|mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TThreadPriority > *", 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__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__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__FileProtocolAdapter = {"_p_mvIMPACT__acquire__GenICam__FileProtocolAdapter", "mvIMPACT::acquire::GenICam::FileProtocolAdapter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__IDevFileStreamBaseT_char_std__char_traitsT_char_t_t = {"_p_mvIMPACT__acquire__GenICam__IDevFileStreamBaseT_char_std__char_traitsT_char_t_t", "mvIMPACT::acquire::GenICam::IDevFileStreamBase< char,std::char_traits< char > > *|mvIMPACT::acquire::GenICam::IDevFileStream *", 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__ODevFileStreamBaseT_char_std__char_traitsT_char_t_t = {"_p_mvIMPACT__acquire__GenICam__ODevFileStreamBaseT_char_std__char_traitsT_char_t_t", "mvIMPACT::acquire::GenICam::ODevFileStreamBase< char,std::char_traits< char > > *|mvIMPACT::acquire::GenICam::ODevFileStream *", 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__mvCurrentControl = {"_p_mvIMPACT__acquire__GenICam__mvCurrentControl", "mvIMPACT::acquire::GenICam::mvCurrentControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__GenICam__mvCustomData = {"_p_mvIMPACT__acquire__GenICam__mvCustomData", "mvIMPACT::acquire::GenICam::mvCustomData *", 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__IOSubSystemBlueCOUGAR = {"_p_mvIMPACT__acquire__IOSubSystemBlueCOUGAR", "mvIMPACT::acquire::IOSubSystemBlueCOUGAR *", 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__TAcquisitionField = {"_p_mvIMPACT__acquire__TAcquisitionField", "enum mvIMPACT::acquire::TAcquisitionField *|mvIMPACT::acquire::TAcquisitionField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TAcquisitionMode = {"_p_mvIMPACT__acquire__TAcquisitionMode", "enum mvIMPACT::acquire::TAcquisitionMode *|mvIMPACT::acquire::TAcquisitionMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TAcquisitionStartStopBehaviour = {"_p_mvIMPACT__acquire__TAcquisitionStartStopBehaviour", "mvIMPACT::acquire::TAcquisitionStartStopBehaviour *|enum mvIMPACT::acquire::TAcquisitionStartStopBehaviour *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TAoiMode = {"_p_mvIMPACT__acquire__TAoiMode", "enum mvIMPACT::acquire::TAoiMode *|mvIMPACT::acquire::TAoiMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TAutoControlMode = {"_p_mvIMPACT__acquire__TAutoControlMode", "enum mvIMPACT::acquire::TAutoControlMode *|mvIMPACT::acquire::TAutoControlMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TAutoControlSpeed = {"_p_mvIMPACT__acquire__TAutoControlSpeed", "enum mvIMPACT::acquire::TAutoControlSpeed *|mvIMPACT::acquire::TAutoControlSpeed *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TAutoExposureControl = {"_p_mvIMPACT__acquire__TAutoExposureControl", "enum mvIMPACT::acquire::TAutoExposureControl *|mvIMPACT::acquire::TAutoExposureControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TAutoGainControl = {"_p_mvIMPACT__acquire__TAutoGainControl", "enum mvIMPACT::acquire::TAutoGainControl *|mvIMPACT::acquire::TAutoGainControl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TAutoOffsetCalibration = {"_p_mvIMPACT__acquire__TAutoOffsetCalibration", "enum mvIMPACT::acquire::TAutoOffsetCalibration *|mvIMPACT::acquire::TAutoOffsetCalibration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TBayerConversionMode = {"_p_mvIMPACT__acquire__TBayerConversionMode", "enum mvIMPACT::acquire::TBayerConversionMode *|mvIMPACT::acquire::TBayerConversionMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TBayerMosaicParity = {"_p_mvIMPACT__acquire__TBayerMosaicParity", "enum mvIMPACT::acquire::TBayerMosaicParity *|mvIMPACT::acquire::TBayerMosaicParity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TBayerWhiteBalanceResult = {"_p_mvIMPACT__acquire__TBayerWhiteBalanceResult", "enum mvIMPACT::acquire::TBayerWhiteBalanceResult *|mvIMPACT::acquire::TBayerWhiteBalanceResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold = {"_p_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold", "mvIMPACT::acquire::TBlueFOXDigitalInputThreshold *|enum mvIMPACT::acquire::TBlueFOXDigitalInputThreshold *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TBlueFOXFooterMode = {"_p_mvIMPACT__acquire__TBlueFOXFooterMode", "enum mvIMPACT::acquire::TBlueFOXFooterMode *|mvIMPACT::acquire::TBlueFOXFooterMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities = {"_p_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities", "mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities *|enum mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed = {"_p_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed", "enum mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed *|mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TBlueFOXSensorTiming = {"_p_mvIMPACT__acquire__TBlueFOXSensorTiming", "enum mvIMPACT::acquire::TBlueFOXSensorTiming *|mvIMPACT::acquire::TBlueFOXSensorTiming *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TBlueFOXTransferSize = {"_p_mvIMPACT__acquire__TBlueFOXTransferSize", "enum mvIMPACT::acquire::TBlueFOXTransferSize *|mvIMPACT::acquire::TBlueFOXTransferSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TBoolean = {"_p_mvIMPACT__acquire__TBoolean", "enum mvIMPACT::acquire::TBoolean *|mvIMPACT::acquire::TBoolean *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TBufferPartDataType = {"_p_mvIMPACT__acquire__TBufferPartDataType", "enum mvIMPACT::acquire::TBufferPartDataType *|mvIMPACT::acquire::TBufferPartDataType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TCameraAoiMode = {"_p_mvIMPACT__acquire__TCameraAoiMode", "enum mvIMPACT::acquire::TCameraAoiMode *|mvIMPACT::acquire::TCameraAoiMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TCameraBinningMode = {"_p_mvIMPACT__acquire__TCameraBinningMode", "enum mvIMPACT::acquire::TCameraBinningMode *|mvIMPACT::acquire::TCameraBinningMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TCameraDataFormat = {"_p_mvIMPACT__acquire__TCameraDataFormat", "enum mvIMPACT::acquire::TCameraDataFormat *|mvIMPACT::acquire::TCameraDataFormat *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TCameraExposeMode = {"_p_mvIMPACT__acquire__TCameraExposeMode", "enum mvIMPACT::acquire::TCameraExposeMode *|mvIMPACT::acquire::TCameraExposeMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TCameraExternalSyncEdge = {"_p_mvIMPACT__acquire__TCameraExternalSyncEdge", "enum mvIMPACT::acquire::TCameraExternalSyncEdge *|mvIMPACT::acquire::TCameraExternalSyncEdge *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TCameraExternalSyncOutput = {"_p_mvIMPACT__acquire__TCameraExternalSyncOutput", "enum mvIMPACT::acquire::TCameraExternalSyncOutput *|mvIMPACT::acquire::TCameraExternalSyncOutput *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TCameraFlashMode = {"_p_mvIMPACT__acquire__TCameraFlashMode", "enum mvIMPACT::acquire::TCameraFlashMode *|mvIMPACT::acquire::TCameraFlashMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TCameraFlashType = {"_p_mvIMPACT__acquire__TCameraFlashType", "enum mvIMPACT::acquire::TCameraFlashType *|mvIMPACT::acquire::TCameraFlashType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TCameraHDRMode = {"_p_mvIMPACT__acquire__TCameraHDRMode", "enum mvIMPACT::acquire::TCameraHDRMode *|mvIMPACT::acquire::TCameraHDRMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TCameraInterlacedType = {"_p_mvIMPACT__acquire__TCameraInterlacedType", "enum mvIMPACT::acquire::TCameraInterlacedType *|mvIMPACT::acquire::TCameraInterlacedType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TCameraLinkDataValidMode = {"_p_mvIMPACT__acquire__TCameraLinkDataValidMode", "enum mvIMPACT::acquire::TCameraLinkDataValidMode *|mvIMPACT::acquire::TCameraLinkDataValidMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TCameraOutput = {"_p_mvIMPACT__acquire__TCameraOutput", "enum mvIMPACT::acquire::TCameraOutput *|mvIMPACT::acquire::TCameraOutput *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TCameraPixelClock = {"_p_mvIMPACT__acquire__TCameraPixelClock", "enum mvIMPACT::acquire::TCameraPixelClock *|mvIMPACT::acquire::TCameraPixelClock *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TCameraScanMode = {"_p_mvIMPACT__acquire__TCameraScanMode", "enum mvIMPACT::acquire::TCameraScanMode *|mvIMPACT::acquire::TCameraScanMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TCameraSerialPortBaudRate = {"_p_mvIMPACT__acquire__TCameraSerialPortBaudRate", "enum mvIMPACT::acquire::TCameraSerialPortBaudRate *|mvIMPACT::acquire::TCameraSerialPortBaudRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TCameraShutterMode = {"_p_mvIMPACT__acquire__TCameraShutterMode", "enum mvIMPACT::acquire::TCameraShutterMode *|mvIMPACT::acquire::TCameraShutterMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TCameraTapsXGeometry = {"_p_mvIMPACT__acquire__TCameraTapsXGeometry", "enum mvIMPACT::acquire::TCameraTapsXGeometry *|mvIMPACT::acquire::TCameraTapsXGeometry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TCameraTapsYGeometry = {"_p_mvIMPACT__acquire__TCameraTapsYGeometry", "enum mvIMPACT::acquire::TCameraTapsYGeometry *|mvIMPACT::acquire::TCameraTapsYGeometry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TCameraTestMode = {"_p_mvIMPACT__acquire__TCameraTestMode", "enum mvIMPACT::acquire::TCameraTestMode *|mvIMPACT::acquire::TCameraTestMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TCameraTriggerMode = {"_p_mvIMPACT__acquire__TCameraTriggerMode", "enum mvIMPACT::acquire::TCameraTriggerMode *|mvIMPACT::acquire::TCameraTriggerMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TCameraTriggerSource = {"_p_mvIMPACT__acquire__TCameraTriggerSource", "enum mvIMPACT::acquire::TCameraTriggerSource *|mvIMPACT::acquire::TCameraTriggerSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TChannelSplitMode = {"_p_mvIMPACT__acquire__TChannelSplitMode", "enum mvIMPACT::acquire::TChannelSplitMode *|mvIMPACT::acquire::TChannelSplitMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TClampMode = {"_p_mvIMPACT__acquire__TClampMode", "enum mvIMPACT::acquire::TClampMode *|mvIMPACT::acquire::TClampMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TColorProcessingMode = {"_p_mvIMPACT__acquire__TColorProcessingMode", "enum mvIMPACT::acquire::TColorProcessingMode *|mvIMPACT::acquire::TColorProcessingMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode = {"_p_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode", "mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode *|enum mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode = {"_p_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode", "enum mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode *|mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDarkCurrentFilterMode = {"_p_mvIMPACT__acquire__TDarkCurrentFilterMode", "enum mvIMPACT::acquire::TDarkCurrentFilterMode *|mvIMPACT::acquire::TDarkCurrentFilterMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDefectivePixelsFilterMode = {"_p_mvIMPACT__acquire__TDefectivePixelsFilterMode", "enum mvIMPACT::acquire::TDefectivePixelsFilterMode *|mvIMPACT::acquire::TDefectivePixelsFilterMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDeviceAccessMode = {"_p_mvIMPACT__acquire__TDeviceAccessMode", "enum mvIMPACT::acquire::TDeviceAccessMode *|mvIMPACT::acquire::TDeviceAccessMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDeviceAdvancedOptions = {"_p_mvIMPACT__acquire__TDeviceAdvancedOptions", "enum mvIMPACT::acquire::TDeviceAdvancedOptions *|mvIMPACT::acquire::TDeviceAdvancedOptions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDeviceCapability = {"_p_mvIMPACT__acquire__TDeviceCapability", "enum mvIMPACT::acquire::TDeviceCapability *|mvIMPACT::acquire::TDeviceCapability *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDeviceClass = {"_p_mvIMPACT__acquire__TDeviceClass", "enum mvIMPACT::acquire::TDeviceClass *|mvIMPACT::acquire::TDeviceClass *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDeviceDigitalOutputMode = {"_p_mvIMPACT__acquire__TDeviceDigitalOutputMode", "enum mvIMPACT::acquire::TDeviceDigitalOutputMode *|mvIMPACT::acquire::TDeviceDigitalOutputMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDeviceEventMode = {"_p_mvIMPACT__acquire__TDeviceEventMode", "enum mvIMPACT::acquire::TDeviceEventMode *|mvIMPACT::acquire::TDeviceEventMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDeviceEventType = {"_p_mvIMPACT__acquire__TDeviceEventType", "enum mvIMPACT::acquire::TDeviceEventType *|mvIMPACT::acquire::TDeviceEventType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDeviceImageTrigger = {"_p_mvIMPACT__acquire__TDeviceImageTrigger", "enum mvIMPACT::acquire::TDeviceImageTrigger *|mvIMPACT::acquire::TDeviceImageTrigger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDeviceInterfaceLayout = {"_p_mvIMPACT__acquire__TDeviceInterfaceLayout", "enum mvIMPACT::acquire::TDeviceInterfaceLayout *|mvIMPACT::acquire::TDeviceInterfaceLayout *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDeviceLoadSettings = {"_p_mvIMPACT__acquire__TDeviceLoadSettings", "enum mvIMPACT::acquire::TDeviceLoadSettings *|mvIMPACT::acquire::TDeviceLoadSettings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDevicePowerMode = {"_p_mvIMPACT__acquire__TDevicePowerMode", "enum mvIMPACT::acquire::TDevicePowerMode *|mvIMPACT::acquire::TDevicePowerMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDeviceScanRateMode = {"_p_mvIMPACT__acquire__TDeviceScanRateMode", "enum mvIMPACT::acquire::TDeviceScanRateMode *|mvIMPACT::acquire::TDeviceScanRateMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDeviceSignalOutputStartEvent = {"_p_mvIMPACT__acquire__TDeviceSignalOutputStartEvent", "mvIMPACT::acquire::TDeviceSignalOutputStartEvent *|enum mvIMPACT::acquire::TDeviceSignalOutputStartEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDeviceState = {"_p_mvIMPACT__acquire__TDeviceState", "enum mvIMPACT::acquire::TDeviceState *|mvIMPACT::acquire::TDeviceState *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDeviceSyncOutMode = {"_p_mvIMPACT__acquire__TDeviceSyncOutMode", "enum mvIMPACT::acquire::TDeviceSyncOutMode *|mvIMPACT::acquire::TDeviceSyncOutMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDeviceTriggerInterface = {"_p_mvIMPACT__acquire__TDeviceTriggerInterface", "enum mvIMPACT::acquire::TDeviceTriggerInterface *|mvIMPACT::acquire::TDeviceTriggerInterface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDeviceTriggerMode = {"_p_mvIMPACT__acquire__TDeviceTriggerMode", "enum mvIMPACT::acquire::TDeviceTriggerMode *|mvIMPACT::acquire::TDeviceTriggerMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDeviceTriggerOverlap = {"_p_mvIMPACT__acquire__TDeviceTriggerOverlap", "enum mvIMPACT::acquire::TDeviceTriggerOverlap *|mvIMPACT::acquire::TDeviceTriggerOverlap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDigIOState = {"_p_mvIMPACT__acquire__TDigIOState", "enum mvIMPACT::acquire::TDigIOState *|mvIMPACT::acquire::TDigIOState *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDigitalIOMeasurementMode = {"_p_mvIMPACT__acquire__TDigitalIOMeasurementMode", "enum mvIMPACT::acquire::TDigitalIOMeasurementMode *|mvIMPACT::acquire::TDigitalIOMeasurementMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDigitalIOMeasurementSource = {"_p_mvIMPACT__acquire__TDigitalIOMeasurementSource", "mvIMPACT::acquire::TDigitalIOMeasurementSource *|enum mvIMPACT::acquire::TDigitalIOMeasurementSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDigitalOutputControlMode = {"_p_mvIMPACT__acquire__TDigitalOutputControlMode", "enum mvIMPACT::acquire::TDigitalOutputControlMode *|mvIMPACT::acquire::TDigitalOutputControlMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TDigitalSignal = {"_p_mvIMPACT__acquire__TDigitalSignal", "enum mvIMPACT::acquire::TDigitalSignal *|mvIMPACT::acquire::TDigitalSignal *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TFieldGateMode = {"_p_mvIMPACT__acquire__TFieldGateMode", "enum mvIMPACT::acquire::TFieldGateMode *|mvIMPACT::acquire::TFieldGateMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode = {"_p_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode", "mvIMPACT::acquire::TFlatFieldFilterCorrectionMode *|enum mvIMPACT::acquire::TFlatFieldFilterCorrectionMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TFlatFieldFilterMode = {"_p_mvIMPACT__acquire__TFlatFieldFilterMode", "enum mvIMPACT::acquire::TFlatFieldFilterMode *|mvIMPACT::acquire::TFlatFieldFilterMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__THWUpdateResult = {"_p_mvIMPACT__acquire__THWUpdateResult", "enum mvIMPACT::acquire::THWUpdateResult *|mvIMPACT::acquire::THWUpdateResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TI2COperationMode = {"_p_mvIMPACT__acquire__TI2COperationMode", "enum mvIMPACT::acquire::TI2COperationMode *|mvIMPACT::acquire::TI2COperationMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TI2COperationStatus = {"_p_mvIMPACT__acquire__TI2COperationStatus", "enum mvIMPACT::acquire::TI2COperationStatus *|mvIMPACT::acquire::TI2COperationStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode = {"_p_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode", "enum mvIMPACT::acquire::TImageBufferFormatReinterpreterMode *|mvIMPACT::acquire::TImageBufferFormatReinterpreterMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TImageBufferPixelFormat = {"_p_mvIMPACT__acquire__TImageBufferPixelFormat", "enum mvIMPACT::acquire::TImageBufferPixelFormat *|mvIMPACT::acquire::TImageBufferPixelFormat *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TImageDestinationPixelFormat = {"_p_mvIMPACT__acquire__TImageDestinationPixelFormat", "enum mvIMPACT::acquire::TImageDestinationPixelFormat *|mvIMPACT::acquire::TImageDestinationPixelFormat *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TImageProcessingFilter = {"_p_mvIMPACT__acquire__TImageProcessingFilter", "enum mvIMPACT::acquire::TImageProcessingFilter *|mvIMPACT::acquire::TImageProcessingFilter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TImageProcessingMode = {"_p_mvIMPACT__acquire__TImageProcessingMode", "enum mvIMPACT::acquire::TImageProcessingMode *|mvIMPACT::acquire::TImageProcessingMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TImageProcessingOptimization = {"_p_mvIMPACT__acquire__TImageProcessingOptimization", "enum mvIMPACT::acquire::TImageProcessingOptimization *|mvIMPACT::acquire::TImageProcessingOptimization *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TImageProcessingResult = {"_p_mvIMPACT__acquire__TImageProcessingResult", "enum mvIMPACT::acquire::TImageProcessingResult *|mvIMPACT::acquire::TImageProcessingResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TImageRequestControlMode = {"_p_mvIMPACT__acquire__TImageRequestControlMode", "enum mvIMPACT::acquire::TImageRequestControlMode *|mvIMPACT::acquire::TImageRequestControlMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TInfoSensorColorMode = {"_p_mvIMPACT__acquire__TInfoSensorColorMode", "enum mvIMPACT::acquire::TInfoSensorColorMode *|mvIMPACT::acquire::TInfoSensorColorMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TInfoSensorType = {"_p_mvIMPACT__acquire__TInfoSensorType", "enum mvIMPACT::acquire::TInfoSensorType *|mvIMPACT::acquire::TInfoSensorType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TInterlacedMode = {"_p_mvIMPACT__acquire__TInterlacedMode", "enum mvIMPACT::acquire::TInterlacedMode *|mvIMPACT::acquire::TInterlacedMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TLUTGammaMode = {"_p_mvIMPACT__acquire__TLUTGammaMode", "enum mvIMPACT::acquire::TLUTGammaMode *|mvIMPACT::acquire::TLUTGammaMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TLUTImplementation = {"_p_mvIMPACT__acquire__TLUTImplementation", "enum mvIMPACT::acquire::TLUTImplementation *|mvIMPACT::acquire::TLUTImplementation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TLUTInterpolationMode = {"_p_mvIMPACT__acquire__TLUTInterpolationMode", "enum mvIMPACT::acquire::TLUTInterpolationMode *|mvIMPACT::acquire::TLUTInterpolationMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TLUTMapping = {"_p_mvIMPACT__acquire__TLUTMapping", "enum mvIMPACT::acquire::TLUTMapping *|mvIMPACT::acquire::TLUTMapping *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TLUTMode = {"_p_mvIMPACT__acquire__TLUTMode", "enum mvIMPACT::acquire::TLUTMode *|mvIMPACT::acquire::TLUTMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TLineCounter = {"_p_mvIMPACT__acquire__TLineCounter", "enum mvIMPACT::acquire::TLineCounter *|mvIMPACT::acquire::TLineCounter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TMemoryManagerMode = {"_p_mvIMPACT__acquire__TMemoryManagerMode", "enum mvIMPACT::acquire::TMemoryManagerMode *|mvIMPACT::acquire::TMemoryManagerMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TMemoryManagerPoolMode = {"_p_mvIMPACT__acquire__TMemoryManagerPoolMode", "enum mvIMPACT::acquire::TMemoryManagerPoolMode *|mvIMPACT::acquire::TMemoryManagerPoolMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TMirrorMode = {"_p_mvIMPACT__acquire__TMirrorMode", "enum mvIMPACT::acquire::TMirrorMode *|mvIMPACT::acquire::TMirrorMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TMirrorOperationMode = {"_p_mvIMPACT__acquire__TMirrorOperationMode", "enum mvIMPACT::acquire::TMirrorOperationMode *|mvIMPACT::acquire::TMirrorOperationMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TOnBoardMemoryMode = {"_p_mvIMPACT__acquire__TOnBoardMemoryMode", "enum mvIMPACT::acquire::TOnBoardMemoryMode *|mvIMPACT::acquire::TOnBoardMemoryMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode = {"_p_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode", "mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode *|enum mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TPolarizedDataExtractionMode = {"_p_mvIMPACT__acquire__TPolarizedDataExtractionMode", "mvIMPACT::acquire::TPolarizedDataExtractionMode *|enum mvIMPACT::acquire::TPolarizedDataExtractionMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TPulseStartTrigger = {"_p_mvIMPACT__acquire__TPulseStartTrigger", "enum mvIMPACT::acquire::TPulseStartTrigger *|mvIMPACT::acquire::TPulseStartTrigger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TRTCtrlModes = {"_p_mvIMPACT__acquire__TRTCtrlModes", "enum mvIMPACT::acquire::TRTCtrlModes *|mvIMPACT::acquire::TRTCtrlModes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TRTProgOpCodes = {"_p_mvIMPACT__acquire__TRTProgOpCodes", "enum mvIMPACT::acquire::TRTProgOpCodes *|mvIMPACT::acquire::TRTProgOpCodes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TRequestImageMemoryMode = {"_p_mvIMPACT__acquire__TRequestImageMemoryMode", "enum mvIMPACT::acquire::TRequestImageMemoryMode *|mvIMPACT::acquire::TRequestImageMemoryMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TRequestResult = {"_p_mvIMPACT__acquire__TRequestResult", "enum mvIMPACT::acquire::TRequestResult *|mvIMPACT::acquire::TRequestResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TRequestState = {"_p_mvIMPACT__acquire__TRequestState", "enum mvIMPACT::acquire::TRequestState *|mvIMPACT::acquire::TRequestState *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TScalerInterpolationMode = {"_p_mvIMPACT__acquire__TScalerInterpolationMode", "enum mvIMPACT::acquire::TScalerInterpolationMode *|mvIMPACT::acquire::TScalerInterpolationMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TScalerMode = {"_p_mvIMPACT__acquire__TScalerMode", "enum mvIMPACT::acquire::TScalerMode *|mvIMPACT::acquire::TScalerMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TScanClock = {"_p_mvIMPACT__acquire__TScanClock", "enum mvIMPACT::acquire::TScanClock *|mvIMPACT::acquire::TScanClock *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TScanStandard = {"_p_mvIMPACT__acquire__TScanStandard", "enum mvIMPACT::acquire::TScanStandard *|mvIMPACT::acquire::TScanStandard *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TThreadPriority = {"_p_mvIMPACT__acquire__TThreadPriority", "enum mvIMPACT::acquire::TThreadPriority *|mvIMPACT::acquire::TThreadPriority *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TTriggerMoment = {"_p_mvIMPACT__acquire__TTriggerMoment", "enum mvIMPACT::acquire::TTriggerMoment *|mvIMPACT::acquire::TTriggerMoment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TUserDataAccessRight = {"_p_mvIMPACT__acquire__TUserDataAccessRight", "enum mvIMPACT::acquire::TUserDataAccessRight *|mvIMPACT::acquire::TUserDataAccessRight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TUserDataReconnectBehaviour = {"_p_mvIMPACT__acquire__TUserDataReconnectBehaviour", "enum mvIMPACT::acquire::TUserDataReconnectBehaviour *|mvIMPACT::acquire::TUserDataReconnectBehaviour *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TVideoStandard = {"_p_mvIMPACT__acquire__TVideoStandard", "enum mvIMPACT::acquire::TVideoStandard *|mvIMPACT::acquire::TVideoStandard *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TVirtualDeviceImageType = {"_p_mvIMPACT__acquire__TVirtualDeviceImageType", "enum mvIMPACT::acquire::TVirtualDeviceImageType *|mvIMPACT::acquire::TVirtualDeviceImageType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TVirtualDeviceTestMode = {"_p_mvIMPACT__acquire__TVirtualDeviceTestMode", "enum mvIMPACT::acquire::TVirtualDeviceTestMode *|mvIMPACT::acquire::TVirtualDeviceTestMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TWhiteBalanceCalibrationMode = {"_p_mvIMPACT__acquire__TWhiteBalanceCalibrationMode", "mvIMPACT::acquire::TWhiteBalanceCalibrationMode *|enum mvIMPACT::acquire::TWhiteBalanceCalibrationMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mvIMPACT__acquire__TWhiteBalanceParameter = {"_p_mvIMPACT__acquire__TWhiteBalanceParameter", "enum mvIMPACT::acquire::TWhiteBalanceParameter *|mvIMPACT::acquire::TWhiteBalanceParameter *", 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_p_mvIMPACT__acquire__Request = {"_p_p_mvIMPACT__acquire__Request", "mvIMPACT::acquire::Request **", 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__ios_base__openmode = {"_p_std__ios_base__openmode", "std::ios_base::openmode *", 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__runtime_error = {"_p_std__runtime_error", "std::runtime_error *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__streamsize = {"_p_std__streamsize", "std::streamsize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_int64_t_t = {"_p_std__vectorT_int64_t_t", "std::vector< int64_t > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_mvIMPACT__acquire__Component_t = {"_p_std__vectorT_mvIMPACT__acquire__Component_t", "std::vector< mvIMPACT::acquire::Component > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_int64_t_t_t = {"_p_std__vectorT_std__pairT_std__string_int64_t_t_t", "std::vector< std::pair< std::string,int64_t > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TAcquisitionField > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TAcquisitionMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TAoiMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TAoiMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TAutoControlMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TAutoControlSpeed > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TAutoExposureControl > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TAutoGainControl > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TAutoOffsetCalibration > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TBayerConversionMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TBayerMosaicParity > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TBayerWhiteBalanceResult > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TBlueFOXFooterMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TBlueFOXSensorTiming > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TBlueFOXTransferSize > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TBoolean > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TBoolean > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TBufferPartDataType > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TCameraAoiMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TCameraBinningMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TCameraDataFormat > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TCameraExposeMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TCameraExternalSyncEdge > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TCameraExternalSyncOutput > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TCameraFlashMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TCameraFlashType > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TCameraHDRMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TCameraInterlacedType > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TCameraLinkDataValidMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraOutput > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TCameraOutput > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TCameraPixelClock > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TCameraScanMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TCameraSerialPortBaudRate > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TCameraShutterMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TCameraTapsXGeometry > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TCameraTapsYGeometry > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TCameraTestMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TCameraTriggerMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TCameraTriggerSource > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TChannelSplitMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TClampMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TClampMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TColorProcessingMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDarkCurrentFilterMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDefectivePixelsFilterMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDeviceAccessMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDeviceAdvancedOptions > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDeviceCapability > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceClass > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDeviceClass > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDeviceDigitalOutputMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceEventMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceEventMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceEventMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDeviceEventMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceEventType_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceEventType_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceEventType > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDeviceEventType > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDeviceImageTrigger > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDeviceInterfaceLayout > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDeviceLoadSettings > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDevicePowerMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDeviceScanRateMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceState > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDeviceState > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDeviceSyncOutMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDeviceTriggerInterface > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDeviceTriggerMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDeviceTriggerOverlap > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDigIOState > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDigIOState > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDigitalIOMeasurementMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDigitalIOMeasurementSource > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDigitalOutputControlMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TDigitalSignal > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TFieldGateMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TFlatFieldFilterMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::THWUpdateResult > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TI2COperationMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TI2COperationStatus > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TImageBufferPixelFormat > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TImageDestinationPixelFormat > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TImageProcessingFilter > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TImageProcessingMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TImageProcessingOptimization > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TImageProcessingResult > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TImageRequestControlMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TInfoSensorColorMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TInfoSensorType > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TInterlacedMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TLUTGammaMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TLUTImplementation > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TLUTInterpolationMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTMapping > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TLUTMapping > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TLUTMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TLineCounter > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TLineCounter > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TMemoryManagerMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TMemoryManagerPoolMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TMirrorMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TMirrorMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TMirrorOperationMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TOnBoardMemoryMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TPolarizedDataExtractionMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TPulseStartTrigger > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TRTCtrlModes > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TRTProgOpCodes > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TRequestImageMemoryMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TRequestResult > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TRequestResult > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TRequestState > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TRequestState > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TScalerInterpolationMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TScalerMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TScalerMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TScanClock > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TScanClock > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TScanStandard > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TScanStandard > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TThreadPriority_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TThreadPriority_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TThreadPriority > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TThreadPriority > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TTriggerMoment > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TUserDataAccessRight > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TUserDataReconnectBehaviour > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TVideoStandard > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TVideoStandard > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TVirtualDeviceImageType > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TVirtualDeviceTestMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t_t = {"_p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t_t", "std::vector< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > > *|std::vector< std::pair< std::string,enum mvIMPACT::acquire::TWhiteBalanceParameter > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__string_t = {"_p_std__vectorT_std__string_t", "std::vector< std::string > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_void_p_t = {"_p_std__vectorT_void_p_t", "std::vector< void * > *", 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_uint64_t = {"_p_uint64_t", "mvIMPACT::acquire::uint64_type *|uint64_t *", 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_double,
  &_swigt__p_first_type,
  &_swigt__p_int,
  &_swigt__p_int16_t,
  &_swigt__p_int32_t,
  &_swigt__p_int64_t,
  &_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_int64_t_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__TBufferPartDataType_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__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__TDeviceEventMode_t,
  &_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_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__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__TThreadPriority_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__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__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__FileProtocolAdapter,
  &_swigt__p_mvIMPACT__acquire__GenICam__IDevFileStreamBaseT_char_std__char_traitsT_char_t_t,
  &_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__ODevFileStreamBaseT_char_std__char_traitsT_char_t_t,
  &_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__mvCurrentControl,
  &_swigt__p_mvIMPACT__acquire__GenICam__mvCustomData,
  &_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__IOSubSystemBlueCOUGAR,
  &_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__TAcquisitionField,
  &_swigt__p_mvIMPACT__acquire__TAcquisitionMode,
  &_swigt__p_mvIMPACT__acquire__TAcquisitionStartStopBehaviour,
  &_swigt__p_mvIMPACT__acquire__TAoiMode,
  &_swigt__p_mvIMPACT__acquire__TAutoControlMode,
  &_swigt__p_mvIMPACT__acquire__TAutoControlSpeed,
  &_swigt__p_mvIMPACT__acquire__TAutoExposureControl,
  &_swigt__p_mvIMPACT__acquire__TAutoGainControl,
  &_swigt__p_mvIMPACT__acquire__TAutoOffsetCalibration,
  &_swigt__p_mvIMPACT__acquire__TBayerConversionMode,
  &_swigt__p_mvIMPACT__acquire__TBayerMosaicParity,
  &_swigt__p_mvIMPACT__acquire__TBayerWhiteBalanceResult,
  &_swigt__p_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold,
  &_swigt__p_mvIMPACT__acquire__TBlueFOXFooterMode,
  &_swigt__p_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities,
  &_swigt__p_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed,
  &_swigt__p_mvIMPACT__acquire__TBlueFOXSensorTiming,
  &_swigt__p_mvIMPACT__acquire__TBlueFOXTransferSize,
  &_swigt__p_mvIMPACT__acquire__TBoolean,
  &_swigt__p_mvIMPACT__acquire__TBufferPartDataType,
  &_swigt__p_mvIMPACT__acquire__TCameraAoiMode,
  &_swigt__p_mvIMPACT__acquire__TCameraBinningMode,
  &_swigt__p_mvIMPACT__acquire__TCameraDataFormat,
  &_swigt__p_mvIMPACT__acquire__TCameraExposeMode,
  &_swigt__p_mvIMPACT__acquire__TCameraExternalSyncEdge,
  &_swigt__p_mvIMPACT__acquire__TCameraExternalSyncOutput,
  &_swigt__p_mvIMPACT__acquire__TCameraFlashMode,
  &_swigt__p_mvIMPACT__acquire__TCameraFlashType,
  &_swigt__p_mvIMPACT__acquire__TCameraHDRMode,
  &_swigt__p_mvIMPACT__acquire__TCameraInterlacedType,
  &_swigt__p_mvIMPACT__acquire__TCameraLinkDataValidMode,
  &_swigt__p_mvIMPACT__acquire__TCameraOutput,
  &_swigt__p_mvIMPACT__acquire__TCameraPixelClock,
  &_swigt__p_mvIMPACT__acquire__TCameraScanMode,
  &_swigt__p_mvIMPACT__acquire__TCameraSerialPortBaudRate,
  &_swigt__p_mvIMPACT__acquire__TCameraShutterMode,
  &_swigt__p_mvIMPACT__acquire__TCameraTapsXGeometry,
  &_swigt__p_mvIMPACT__acquire__TCameraTapsYGeometry,
  &_swigt__p_mvIMPACT__acquire__TCameraTestMode,
  &_swigt__p_mvIMPACT__acquire__TCameraTriggerMode,
  &_swigt__p_mvIMPACT__acquire__TCameraTriggerSource,
  &_swigt__p_mvIMPACT__acquire__TChannelSplitMode,
  &_swigt__p_mvIMPACT__acquire__TClampMode,
  &_swigt__p_mvIMPACT__acquire__TColorProcessingMode,
  &_swigt__p_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode,
  &_swigt__p_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode,
  &_swigt__p_mvIMPACT__acquire__TDarkCurrentFilterMode,
  &_swigt__p_mvIMPACT__acquire__TDefectivePixelsFilterMode,
  &_swigt__p_mvIMPACT__acquire__TDeviceAccessMode,
  &_swigt__p_mvIMPACT__acquire__TDeviceAdvancedOptions,
  &_swigt__p_mvIMPACT__acquire__TDeviceCapability,
  &_swigt__p_mvIMPACT__acquire__TDeviceClass,
  &_swigt__p_mvIMPACT__acquire__TDeviceDigitalOutputMode,
  &_swigt__p_mvIMPACT__acquire__TDeviceEventMode,
  &_swigt__p_mvIMPACT__acquire__TDeviceEventType,
  &_swigt__p_mvIMPACT__acquire__TDeviceImageTrigger,
  &_swigt__p_mvIMPACT__acquire__TDeviceInterfaceLayout,
  &_swigt__p_mvIMPACT__acquire__TDeviceLoadSettings,
  &_swigt__p_mvIMPACT__acquire__TDevicePowerMode,
  &_swigt__p_mvIMPACT__acquire__TDeviceScanRateMode,
  &_swigt__p_mvIMPACT__acquire__TDeviceSignalOutputStartEvent,
  &_swigt__p_mvIMPACT__acquire__TDeviceState,
  &_swigt__p_mvIMPACT__acquire__TDeviceSyncOutMode,
  &_swigt__p_mvIMPACT__acquire__TDeviceTriggerInterface,
  &_swigt__p_mvIMPACT__acquire__TDeviceTriggerMode,
  &_swigt__p_mvIMPACT__acquire__TDeviceTriggerOverlap,
  &_swigt__p_mvIMPACT__acquire__TDigIOState,
  &_swigt__p_mvIMPACT__acquire__TDigitalIOMeasurementMode,
  &_swigt__p_mvIMPACT__acquire__TDigitalIOMeasurementSource,
  &_swigt__p_mvIMPACT__acquire__TDigitalOutputControlMode,
  &_swigt__p_mvIMPACT__acquire__TDigitalSignal,
  &_swigt__p_mvIMPACT__acquire__TFieldGateMode,
  &_swigt__p_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode,
  &_swigt__p_mvIMPACT__acquire__TFlatFieldFilterMode,
  &_swigt__p_mvIMPACT__acquire__THWUpdateResult,
  &_swigt__p_mvIMPACT__acquire__TI2COperationMode,
  &_swigt__p_mvIMPACT__acquire__TI2COperationStatus,
  &_swigt__p_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode,
  &_swigt__p_mvIMPACT__acquire__TImageBufferPixelFormat,
  &_swigt__p_mvIMPACT__acquire__TImageDestinationPixelFormat,
  &_swigt__p_mvIMPACT__acquire__TImageProcessingFilter,
  &_swigt__p_mvIMPACT__acquire__TImageProcessingMode,
  &_swigt__p_mvIMPACT__acquire__TImageProcessingOptimization,
  &_swigt__p_mvIMPACT__acquire__TImageProcessingResult,
  &_swigt__p_mvIMPACT__acquire__TImageRequestControlMode,
  &_swigt__p_mvIMPACT__acquire__TInfoSensorColorMode,
  &_swigt__p_mvIMPACT__acquire__TInfoSensorType,
  &_swigt__p_mvIMPACT__acquire__TInterlacedMode,
  &_swigt__p_mvIMPACT__acquire__TLUTGammaMode,
  &_swigt__p_mvIMPACT__acquire__TLUTImplementation,
  &_swigt__p_mvIMPACT__acquire__TLUTInterpolationMode,
  &_swigt__p_mvIMPACT__acquire__TLUTMapping,
  &_swigt__p_mvIMPACT__acquire__TLUTMode,
  &_swigt__p_mvIMPACT__acquire__TLineCounter,
  &_swigt__p_mvIMPACT__acquire__TMemoryManagerMode,
  &_swigt__p_mvIMPACT__acquire__TMemoryManagerPoolMode,
  &_swigt__p_mvIMPACT__acquire__TMirrorMode,
  &_swigt__p_mvIMPACT__acquire__TMirrorOperationMode,
  &_swigt__p_mvIMPACT__acquire__TOnBoardMemoryMode,
  &_swigt__p_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode,
  &_swigt__p_mvIMPACT__acquire__TPolarizedDataExtractionMode,
  &_swigt__p_mvIMPACT__acquire__TPulseStartTrigger,
  &_swigt__p_mvIMPACT__acquire__TRTCtrlModes,
  &_swigt__p_mvIMPACT__acquire__TRTProgOpCodes,
  &_swigt__p_mvIMPACT__acquire__TRequestImageMemoryMode,
  &_swigt__p_mvIMPACT__acquire__TRequestResult,
  &_swigt__p_mvIMPACT__acquire__TRequestState,
  &_swigt__p_mvIMPACT__acquire__TScalerInterpolationMode,
  &_swigt__p_mvIMPACT__acquire__TScalerMode,
  &_swigt__p_mvIMPACT__acquire__TScanClock,
  &_swigt__p_mvIMPACT__acquire__TScanStandard,
  &_swigt__p_mvIMPACT__acquire__TThreadPriority,
  &_swigt__p_mvIMPACT__acquire__TTriggerMoment,
  &_swigt__p_mvIMPACT__acquire__TUserDataAccessRight,
  &_swigt__p_mvIMPACT__acquire__TUserDataReconnectBehaviour,
  &_swigt__p_mvIMPACT__acquire__TVideoStandard,
  &_swigt__p_mvIMPACT__acquire__TVirtualDeviceImageType,
  &_swigt__p_mvIMPACT__acquire__TVirtualDeviceTestMode,
  &_swigt__p_mvIMPACT__acquire__TWhiteBalanceCalibrationMode,
  &_swigt__p_mvIMPACT__acquire__TWhiteBalanceParameter,
  &_swigt__p_mvIMPACT__acquire__TriggerControl,
  &_swigt__p_mvIMPACT__acquire__UserData,
  &_swigt__p_mvIMPACT__acquire__UserDataEntry,
  &_swigt__p_mvIMPACT__acquire__WhiteBalanceSettings,
  &_swigt__p_p_mvIMPACT__acquire__Request,
  &_swigt__p_second_type,
  &_swigt__p_std__ios_base__openmode,
  &_swigt__p_std__pairT_std__string_double_t,
  &_swigt__p_std__pairT_std__string_int_t,
  &_swigt__p_std__runtime_error,
  &_swigt__p_std__streamsize,
  &_swigt__p_std__vectorT_int64_t_t,
  &_swigt__p_std__vectorT_mvIMPACT__acquire__Component_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_int64_t_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceEventMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceEventType_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TThreadPriority_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t_t,
  &_swigt__p_std__vectorT_std__string_t,
  &_swigt__p_std__vectorT_void_p_t,
  &_swigt__p_uint16_t,
  &_swigt__p_uint32_t,
  &_swigt__p_uint64_t,
  &_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_double[] = {  {&_swigt__p_double, 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_int64_t[] = {  {&_swigt__p_int64_t, 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__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__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__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__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__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__TThreadPriority_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_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__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_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__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__TBlueFOXDigitalInputThreshold_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_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__TBlueFOXInfoSensorCapabilities_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_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__TCameraExposeMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_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__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__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__TMirrorOperationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_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__TLUTMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_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__TLUTInterpolationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_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__TLUTGammaMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_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__TColorProcessingMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_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__TColorTwistInputCorrectionMatrixMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBufferPartDataType_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBufferPartDataType_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__TImageBufferPixelFormat_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_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__TDeviceState_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_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__TDeviceInterfaceLayout_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_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__TDeviceCapability_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_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__TDefectivePixelsFilterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_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__TBayerConversionMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_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__TBayerWhiteBalanceResult_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_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__TCameraOutput_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_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__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__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__TCameraPixelClock_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_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__TCameraShutterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_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__TCameraTapsYGeometry_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_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__TCameraSerialPortBaudRate_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_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__TClampMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_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__TDeviceDigitalOutputMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_tTo_p_mvIMPACT__acquire__Component, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_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__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__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__TDigitalIOMeasurementMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_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__TDigitalOutputControlMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_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__TFieldGateMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_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__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__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__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__TOnBoardMemoryMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_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__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__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__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_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__EnumPropertyI64T_int64_t_t, _p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_tTo_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__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__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__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__TThreadPriority_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_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__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__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__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__TAutoExposureControl_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoExposureControl_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__TAutoOffsetCalibration_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TAutoOffsetCalibration_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__TBlueFOXFooterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXFooterMode_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__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__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__TMirrorOperationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_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__TLUTMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_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__TLUTInterpolationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_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__TLUTGammaMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_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__TColorTwistInputCorrectionMatrixMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_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__TCameraOutput_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_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__TBayerWhiteBalanceResult_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_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__TImageProcessingFilter_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageProcessingFilter_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__TImageBufferFormatReinterpreterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBufferPartDataType_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBufferPartDataType_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__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__TDeviceState_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_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__TDeviceInterfaceLayout_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_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__TDeviceCapability_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_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__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__TBayerConversionMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerConversionMode_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__TRequestResult_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TRequestResult_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__TPolarizedDataExtractionMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TPolarizedDataExtractionMode_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__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__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__TCameraPixelClock_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_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__TCameraShutterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_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__TCameraTapsYGeometry_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_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__TCameraSerialPortBaudRate_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_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__TClampMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_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__TDeviceDigitalOutputMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_tTo_p_mvIMPACT__acquire__ComponentAccess, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_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__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__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__TDigitalIOMeasurementMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_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__TDigitalOutputControlMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_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__TFieldGateMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_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__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__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__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__TOnBoardMemoryMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_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__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__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__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__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__EnumPropertyI64T_int64_t_t, _p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_tTo_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__TriggerControl, _p_mvIMPACT__acquire__TriggerControlTo_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__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__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__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__GenICam__mvCustomData, _p_mvIMPACT__acquire__GenICam__mvCustomDataTo_p_mvIMPACT__acquire__ComponentCollection, 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__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__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_int64_t_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_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__TBufferPartDataType_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBufferPartDataType_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__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__TDeviceEventMode_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_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__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__TThreadPriority_t[] = {  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_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__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__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__FileProtocolAdapter[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__FileProtocolAdapter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__IDevFileStreamBaseT_char_std__char_traitsT_char_t_t[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__IDevFileStreamBaseT_char_std__char_traitsT_char_t_t, 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__ODevFileStreamBaseT_char_std__char_traitsT_char_t_t[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__ODevFileStreamBaseT_char_std__char_traitsT_char_t_t, 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__mvCurrentControl[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__mvCurrentControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__GenICam__mvCustomData[] = {  {&_swigt__p_mvIMPACT__acquire__GenICam__mvCustomData, 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__IOSubSystemBlueCOUGAR, _p_mvIMPACT__acquire__IOSubSystemBlueCOUGARTo_p_mvIMPACT__acquire__IOSubSystem, 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__IOSubSystemBlueCOUGAR[] = {  {&_swigt__p_mvIMPACT__acquire__IOSubSystemBlueCOUGAR, 0, 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__IOSubSystemBlueCOUGAR, _p_mvIMPACT__acquire__IOSubSystemBlueCOUGARTo_p_mvIMPACT__acquire__IOSubSystemCommon, 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__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__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__TCameraExternalSyncOutput_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExternalSyncOutput_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__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__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__TThreadPriority_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TThreadPriority_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__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_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__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__TBlueFOXDigitalInputThreshold_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_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__TBlueFOXInfoSensorCapabilities_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_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__TCameraExposeMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraExposeMode_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__TCameraBinningMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraBinningMode_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__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__TMirrorOperationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TMirrorOperationMode_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__TLUTMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTMode_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__TLUTInterpolationMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTInterpolationMode_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__TLUTGammaMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TLUTGammaMode_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__TColorProcessingMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorProcessingMode_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__TImageBufferPixelFormat_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TImageBufferPixelFormat_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBufferPartDataType_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBufferPartDataType_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__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__TDeviceState_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceState_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__TDeviceInterfaceLayout_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceInterfaceLayout_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__TDeviceCapability_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceCapability_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__TDefectivePixelsFilterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDefectivePixelsFilterMode_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__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__TBayerWhiteBalanceResult_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TBayerWhiteBalanceResult_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__TCameraOutput_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraOutput_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__TColorTwistInputCorrectionMatrixMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_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__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__TCameraPixelClock_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraPixelClock_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__TCameraShutterMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraShutterMode_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__TCameraTapsYGeometry_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraTapsYGeometry_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__TCameraSerialPortBaudRate_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TCameraSerialPortBaudRate_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__TClampMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TClampMode_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__TDeviceDigitalOutputMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceDigitalOutputMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventMode_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_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__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__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__TDigitalIOMeasurementMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalIOMeasurementMode_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__TDigitalOutputControlMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDigitalOutputControlMode_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__TFieldGateMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TFieldGateMode_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__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__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__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__TOnBoardMemoryMode_t, _p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TOnBoardMemoryMode_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__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__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__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_int_t, _p_mvIMPACT__acquire__EnumPropertyIT_int_tTo_p_mvIMPACT__acquire__Property, 0, 0},  {&_swigt__p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_t, _p_mvIMPACT__acquire__EnumPropertyI64T_int64_t_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__TAcquisitionField[] = {  {&_swigt__p_mvIMPACT__acquire__TAcquisitionField, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TAcquisitionMode[] = {  {&_swigt__p_mvIMPACT__acquire__TAcquisitionMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TAcquisitionStartStopBehaviour[] = {  {&_swigt__p_mvIMPACT__acquire__TAcquisitionStartStopBehaviour, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TAoiMode[] = {  {&_swigt__p_mvIMPACT__acquire__TAoiMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TAutoControlMode[] = {  {&_swigt__p_mvIMPACT__acquire__TAutoControlMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TAutoControlSpeed[] = {  {&_swigt__p_mvIMPACT__acquire__TAutoControlSpeed, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TAutoExposureControl[] = {  {&_swigt__p_mvIMPACT__acquire__TAutoExposureControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TAutoGainControl[] = {  {&_swigt__p_mvIMPACT__acquire__TAutoGainControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TAutoOffsetCalibration[] = {  {&_swigt__p_mvIMPACT__acquire__TAutoOffsetCalibration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TBayerConversionMode[] = {  {&_swigt__p_mvIMPACT__acquire__TBayerConversionMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TBayerMosaicParity[] = {  {&_swigt__p_mvIMPACT__acquire__TBayerMosaicParity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TBayerWhiteBalanceResult[] = {  {&_swigt__p_mvIMPACT__acquire__TBayerWhiteBalanceResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold[] = {  {&_swigt__p_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TBlueFOXFooterMode[] = {  {&_swigt__p_mvIMPACT__acquire__TBlueFOXFooterMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities[] = {  {&_swigt__p_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed[] = {  {&_swigt__p_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TBlueFOXSensorTiming[] = {  {&_swigt__p_mvIMPACT__acquire__TBlueFOXSensorTiming, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TBlueFOXTransferSize[] = {  {&_swigt__p_mvIMPACT__acquire__TBlueFOXTransferSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TBoolean[] = {  {&_swigt__p_mvIMPACT__acquire__TBoolean, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TBufferPartDataType[] = {  {&_swigt__p_mvIMPACT__acquire__TBufferPartDataType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TCameraAoiMode[] = {  {&_swigt__p_mvIMPACT__acquire__TCameraAoiMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TCameraBinningMode[] = {  {&_swigt__p_mvIMPACT__acquire__TCameraBinningMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TCameraDataFormat[] = {  {&_swigt__p_mvIMPACT__acquire__TCameraDataFormat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TCameraExposeMode[] = {  {&_swigt__p_mvIMPACT__acquire__TCameraExposeMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TCameraExternalSyncEdge[] = {  {&_swigt__p_mvIMPACT__acquire__TCameraExternalSyncEdge, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TCameraExternalSyncOutput[] = {  {&_swigt__p_mvIMPACT__acquire__TCameraExternalSyncOutput, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TCameraFlashMode[] = {  {&_swigt__p_mvIMPACT__acquire__TCameraFlashMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TCameraFlashType[] = {  {&_swigt__p_mvIMPACT__acquire__TCameraFlashType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TCameraHDRMode[] = {  {&_swigt__p_mvIMPACT__acquire__TCameraHDRMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TCameraInterlacedType[] = {  {&_swigt__p_mvIMPACT__acquire__TCameraInterlacedType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TCameraLinkDataValidMode[] = {  {&_swigt__p_mvIMPACT__acquire__TCameraLinkDataValidMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TCameraOutput[] = {  {&_swigt__p_mvIMPACT__acquire__TCameraOutput, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TCameraPixelClock[] = {  {&_swigt__p_mvIMPACT__acquire__TCameraPixelClock, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TCameraScanMode[] = {  {&_swigt__p_mvIMPACT__acquire__TCameraScanMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TCameraSerialPortBaudRate[] = {  {&_swigt__p_mvIMPACT__acquire__TCameraSerialPortBaudRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TCameraShutterMode[] = {  {&_swigt__p_mvIMPACT__acquire__TCameraShutterMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TCameraTapsXGeometry[] = {  {&_swigt__p_mvIMPACT__acquire__TCameraTapsXGeometry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TCameraTapsYGeometry[] = {  {&_swigt__p_mvIMPACT__acquire__TCameraTapsYGeometry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TCameraTestMode[] = {  {&_swigt__p_mvIMPACT__acquire__TCameraTestMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TCameraTriggerMode[] = {  {&_swigt__p_mvIMPACT__acquire__TCameraTriggerMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TCameraTriggerSource[] = {  {&_swigt__p_mvIMPACT__acquire__TCameraTriggerSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TChannelSplitMode[] = {  {&_swigt__p_mvIMPACT__acquire__TChannelSplitMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TClampMode[] = {  {&_swigt__p_mvIMPACT__acquire__TClampMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TColorProcessingMode[] = {  {&_swigt__p_mvIMPACT__acquire__TColorProcessingMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode[] = {  {&_swigt__p_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode[] = {  {&_swigt__p_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDarkCurrentFilterMode[] = {  {&_swigt__p_mvIMPACT__acquire__TDarkCurrentFilterMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDefectivePixelsFilterMode[] = {  {&_swigt__p_mvIMPACT__acquire__TDefectivePixelsFilterMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDeviceAccessMode[] = {  {&_swigt__p_mvIMPACT__acquire__TDeviceAccessMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDeviceAdvancedOptions[] = {  {&_swigt__p_mvIMPACT__acquire__TDeviceAdvancedOptions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDeviceCapability[] = {  {&_swigt__p_mvIMPACT__acquire__TDeviceCapability, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDeviceClass[] = {  {&_swigt__p_mvIMPACT__acquire__TDeviceClass, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDeviceDigitalOutputMode[] = {  {&_swigt__p_mvIMPACT__acquire__TDeviceDigitalOutputMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDeviceEventMode[] = {  {&_swigt__p_mvIMPACT__acquire__TDeviceEventMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDeviceEventType[] = {  {&_swigt__p_mvIMPACT__acquire__TDeviceEventType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDeviceImageTrigger[] = {  {&_swigt__p_mvIMPACT__acquire__TDeviceImageTrigger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDeviceInterfaceLayout[] = {  {&_swigt__p_mvIMPACT__acquire__TDeviceInterfaceLayout, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDeviceLoadSettings[] = {  {&_swigt__p_mvIMPACT__acquire__TDeviceLoadSettings, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDevicePowerMode[] = {  {&_swigt__p_mvIMPACT__acquire__TDevicePowerMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDeviceScanRateMode[] = {  {&_swigt__p_mvIMPACT__acquire__TDeviceScanRateMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDeviceSignalOutputStartEvent[] = {  {&_swigt__p_mvIMPACT__acquire__TDeviceSignalOutputStartEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDeviceState[] = {  {&_swigt__p_mvIMPACT__acquire__TDeviceState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDeviceSyncOutMode[] = {  {&_swigt__p_mvIMPACT__acquire__TDeviceSyncOutMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDeviceTriggerInterface[] = {  {&_swigt__p_mvIMPACT__acquire__TDeviceTriggerInterface, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDeviceTriggerMode[] = {  {&_swigt__p_mvIMPACT__acquire__TDeviceTriggerMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDeviceTriggerOverlap[] = {  {&_swigt__p_mvIMPACT__acquire__TDeviceTriggerOverlap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDigIOState[] = {  {&_swigt__p_mvIMPACT__acquire__TDigIOState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDigitalIOMeasurementMode[] = {  {&_swigt__p_mvIMPACT__acquire__TDigitalIOMeasurementMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDigitalIOMeasurementSource[] = {  {&_swigt__p_mvIMPACT__acquire__TDigitalIOMeasurementSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDigitalOutputControlMode[] = {  {&_swigt__p_mvIMPACT__acquire__TDigitalOutputControlMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TDigitalSignal[] = {  {&_swigt__p_mvIMPACT__acquire__TDigitalSignal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TFieldGateMode[] = {  {&_swigt__p_mvIMPACT__acquire__TFieldGateMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode[] = {  {&_swigt__p_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TFlatFieldFilterMode[] = {  {&_swigt__p_mvIMPACT__acquire__TFlatFieldFilterMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__THWUpdateResult[] = {  {&_swigt__p_mvIMPACT__acquire__THWUpdateResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TI2COperationMode[] = {  {&_swigt__p_mvIMPACT__acquire__TI2COperationMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TI2COperationStatus[] = {  {&_swigt__p_mvIMPACT__acquire__TI2COperationStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode[] = {  {&_swigt__p_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TImageBufferPixelFormat[] = {  {&_swigt__p_mvIMPACT__acquire__TImageBufferPixelFormat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TImageDestinationPixelFormat[] = {  {&_swigt__p_mvIMPACT__acquire__TImageDestinationPixelFormat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TImageProcessingFilter[] = {  {&_swigt__p_mvIMPACT__acquire__TImageProcessingFilter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TImageProcessingMode[] = {  {&_swigt__p_mvIMPACT__acquire__TImageProcessingMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TImageProcessingOptimization[] = {  {&_swigt__p_mvIMPACT__acquire__TImageProcessingOptimization, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TImageProcessingResult[] = {  {&_swigt__p_mvIMPACT__acquire__TImageProcessingResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TImageRequestControlMode[] = {  {&_swigt__p_mvIMPACT__acquire__TImageRequestControlMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TInfoSensorColorMode[] = {  {&_swigt__p_mvIMPACT__acquire__TInfoSensorColorMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TInfoSensorType[] = {  {&_swigt__p_mvIMPACT__acquire__TInfoSensorType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TInterlacedMode[] = {  {&_swigt__p_mvIMPACT__acquire__TInterlacedMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TLUTGammaMode[] = {  {&_swigt__p_mvIMPACT__acquire__TLUTGammaMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TLUTImplementation[] = {  {&_swigt__p_mvIMPACT__acquire__TLUTImplementation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TLUTInterpolationMode[] = {  {&_swigt__p_mvIMPACT__acquire__TLUTInterpolationMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TLUTMapping[] = {  {&_swigt__p_mvIMPACT__acquire__TLUTMapping, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TLUTMode[] = {  {&_swigt__p_mvIMPACT__acquire__TLUTMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TLineCounter[] = {  {&_swigt__p_mvIMPACT__acquire__TLineCounter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TMemoryManagerMode[] = {  {&_swigt__p_mvIMPACT__acquire__TMemoryManagerMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TMemoryManagerPoolMode[] = {  {&_swigt__p_mvIMPACT__acquire__TMemoryManagerPoolMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TMirrorMode[] = {  {&_swigt__p_mvIMPACT__acquire__TMirrorMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TMirrorOperationMode[] = {  {&_swigt__p_mvIMPACT__acquire__TMirrorOperationMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TOnBoardMemoryMode[] = {  {&_swigt__p_mvIMPACT__acquire__TOnBoardMemoryMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode[] = {  {&_swigt__p_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TPolarizedDataExtractionMode[] = {  {&_swigt__p_mvIMPACT__acquire__TPolarizedDataExtractionMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TPulseStartTrigger[] = {  {&_swigt__p_mvIMPACT__acquire__TPulseStartTrigger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TRTCtrlModes[] = {  {&_swigt__p_mvIMPACT__acquire__TRTCtrlModes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TRTProgOpCodes[] = {  {&_swigt__p_mvIMPACT__acquire__TRTProgOpCodes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TRequestImageMemoryMode[] = {  {&_swigt__p_mvIMPACT__acquire__TRequestImageMemoryMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TRequestResult[] = {  {&_swigt__p_mvIMPACT__acquire__TRequestResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TRequestState[] = {  {&_swigt__p_mvIMPACT__acquire__TRequestState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TScalerInterpolationMode[] = {  {&_swigt__p_mvIMPACT__acquire__TScalerInterpolationMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TScalerMode[] = {  {&_swigt__p_mvIMPACT__acquire__TScalerMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TScanClock[] = {  {&_swigt__p_mvIMPACT__acquire__TScanClock, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TScanStandard[] = {  {&_swigt__p_mvIMPACT__acquire__TScanStandard, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TThreadPriority[] = {  {&_swigt__p_mvIMPACT__acquire__TThreadPriority, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TTriggerMoment[] = {  {&_swigt__p_mvIMPACT__acquire__TTriggerMoment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TUserDataAccessRight[] = {  {&_swigt__p_mvIMPACT__acquire__TUserDataAccessRight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TUserDataReconnectBehaviour[] = {  {&_swigt__p_mvIMPACT__acquire__TUserDataReconnectBehaviour, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TVideoStandard[] = {  {&_swigt__p_mvIMPACT__acquire__TVideoStandard, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TVirtualDeviceImageType[] = {  {&_swigt__p_mvIMPACT__acquire__TVirtualDeviceImageType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TVirtualDeviceTestMode[] = {  {&_swigt__p_mvIMPACT__acquire__TVirtualDeviceTestMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TWhiteBalanceCalibrationMode[] = {  {&_swigt__p_mvIMPACT__acquire__TWhiteBalanceCalibrationMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mvIMPACT__acquire__TWhiteBalanceParameter[] = {  {&_swigt__p_mvIMPACT__acquire__TWhiteBalanceParameter, 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_p_mvIMPACT__acquire__Request[] = {  {&_swigt__p_p_mvIMPACT__acquire__Request, 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__ios_base__openmode[] = {  {&_swigt__p_std__ios_base__openmode, 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__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__streamsize[] = {  {&_swigt__p_std__streamsize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_int64_t_t[] = {  {&_swigt__p_std__vectorT_int64_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_mvIMPACT__acquire__Component_t[] = {  {&_swigt__p_std__vectorT_mvIMPACT__acquire__Component_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_int64_t_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_int64_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceEventMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceEventMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceEventType_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceEventType_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_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_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TThreadPriority_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TThreadPriority_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__string_t[] = {  {&_swigt__p_std__vectorT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_void_p_t[] = {  {&_swigt__p_std__vectorT_void_p_t, 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_uint64_t[] = {  {&_swigt__p_uint64_t, 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_double,
  _swigc__p_first_type,
  _swigc__p_int,
  _swigc__p_int16_t,
  _swigc__p_int32_t,
  _swigc__p_int64_t,
  _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_int64_t_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__TBufferPartDataType_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__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__TDeviceEventMode_t,
  _swigc__p_mvIMPACT__acquire__EnumPropertyIT_mvIMPACT__acquire__TDeviceEventType_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__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__TThreadPriority_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__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__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__FileProtocolAdapter,
  _swigc__p_mvIMPACT__acquire__GenICam__IDevFileStreamBaseT_char_std__char_traitsT_char_t_t,
  _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__ODevFileStreamBaseT_char_std__char_traitsT_char_t_t,
  _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__mvCurrentControl,
  _swigc__p_mvIMPACT__acquire__GenICam__mvCustomData,
  _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__IOSubSystemBlueCOUGAR,
  _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__TAcquisitionField,
  _swigc__p_mvIMPACT__acquire__TAcquisitionMode,
  _swigc__p_mvIMPACT__acquire__TAcquisitionStartStopBehaviour,
  _swigc__p_mvIMPACT__acquire__TAoiMode,
  _swigc__p_mvIMPACT__acquire__TAutoControlMode,
  _swigc__p_mvIMPACT__acquire__TAutoControlSpeed,
  _swigc__p_mvIMPACT__acquire__TAutoExposureControl,
  _swigc__p_mvIMPACT__acquire__TAutoGainControl,
  _swigc__p_mvIMPACT__acquire__TAutoOffsetCalibration,
  _swigc__p_mvIMPACT__acquire__TBayerConversionMode,
  _swigc__p_mvIMPACT__acquire__TBayerMosaicParity,
  _swigc__p_mvIMPACT__acquire__TBayerWhiteBalanceResult,
  _swigc__p_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold,
  _swigc__p_mvIMPACT__acquire__TBlueFOXFooterMode,
  _swigc__p_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities,
  _swigc__p_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed,
  _swigc__p_mvIMPACT__acquire__TBlueFOXSensorTiming,
  _swigc__p_mvIMPACT__acquire__TBlueFOXTransferSize,
  _swigc__p_mvIMPACT__acquire__TBoolean,
  _swigc__p_mvIMPACT__acquire__TBufferPartDataType,
  _swigc__p_mvIMPACT__acquire__TCameraAoiMode,
  _swigc__p_mvIMPACT__acquire__TCameraBinningMode,
  _swigc__p_mvIMPACT__acquire__TCameraDataFormat,
  _swigc__p_mvIMPACT__acquire__TCameraExposeMode,
  _swigc__p_mvIMPACT__acquire__TCameraExternalSyncEdge,
  _swigc__p_mvIMPACT__acquire__TCameraExternalSyncOutput,
  _swigc__p_mvIMPACT__acquire__TCameraFlashMode,
  _swigc__p_mvIMPACT__acquire__TCameraFlashType,
  _swigc__p_mvIMPACT__acquire__TCameraHDRMode,
  _swigc__p_mvIMPACT__acquire__TCameraInterlacedType,
  _swigc__p_mvIMPACT__acquire__TCameraLinkDataValidMode,
  _swigc__p_mvIMPACT__acquire__TCameraOutput,
  _swigc__p_mvIMPACT__acquire__TCameraPixelClock,
  _swigc__p_mvIMPACT__acquire__TCameraScanMode,
  _swigc__p_mvIMPACT__acquire__TCameraSerialPortBaudRate,
  _swigc__p_mvIMPACT__acquire__TCameraShutterMode,
  _swigc__p_mvIMPACT__acquire__TCameraTapsXGeometry,
  _swigc__p_mvIMPACT__acquire__TCameraTapsYGeometry,
  _swigc__p_mvIMPACT__acquire__TCameraTestMode,
  _swigc__p_mvIMPACT__acquire__TCameraTriggerMode,
  _swigc__p_mvIMPACT__acquire__TCameraTriggerSource,
  _swigc__p_mvIMPACT__acquire__TChannelSplitMode,
  _swigc__p_mvIMPACT__acquire__TClampMode,
  _swigc__p_mvIMPACT__acquire__TColorProcessingMode,
  _swigc__p_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode,
  _swigc__p_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode,
  _swigc__p_mvIMPACT__acquire__TDarkCurrentFilterMode,
  _swigc__p_mvIMPACT__acquire__TDefectivePixelsFilterMode,
  _swigc__p_mvIMPACT__acquire__TDeviceAccessMode,
  _swigc__p_mvIMPACT__acquire__TDeviceAdvancedOptions,
  _swigc__p_mvIMPACT__acquire__TDeviceCapability,
  _swigc__p_mvIMPACT__acquire__TDeviceClass,
  _swigc__p_mvIMPACT__acquire__TDeviceDigitalOutputMode,
  _swigc__p_mvIMPACT__acquire__TDeviceEventMode,
  _swigc__p_mvIMPACT__acquire__TDeviceEventType,
  _swigc__p_mvIMPACT__acquire__TDeviceImageTrigger,
  _swigc__p_mvIMPACT__acquire__TDeviceInterfaceLayout,
  _swigc__p_mvIMPACT__acquire__TDeviceLoadSettings,
  _swigc__p_mvIMPACT__acquire__TDevicePowerMode,
  _swigc__p_mvIMPACT__acquire__TDeviceScanRateMode,
  _swigc__p_mvIMPACT__acquire__TDeviceSignalOutputStartEvent,
  _swigc__p_mvIMPACT__acquire__TDeviceState,
  _swigc__p_mvIMPACT__acquire__TDeviceSyncOutMode,
  _swigc__p_mvIMPACT__acquire__TDeviceTriggerInterface,
  _swigc__p_mvIMPACT__acquire__TDeviceTriggerMode,
  _swigc__p_mvIMPACT__acquire__TDeviceTriggerOverlap,
  _swigc__p_mvIMPACT__acquire__TDigIOState,
  _swigc__p_mvIMPACT__acquire__TDigitalIOMeasurementMode,
  _swigc__p_mvIMPACT__acquire__TDigitalIOMeasurementSource,
  _swigc__p_mvIMPACT__acquire__TDigitalOutputControlMode,
  _swigc__p_mvIMPACT__acquire__TDigitalSignal,
  _swigc__p_mvIMPACT__acquire__TFieldGateMode,
  _swigc__p_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode,
  _swigc__p_mvIMPACT__acquire__TFlatFieldFilterMode,
  _swigc__p_mvIMPACT__acquire__THWUpdateResult,
  _swigc__p_mvIMPACT__acquire__TI2COperationMode,
  _swigc__p_mvIMPACT__acquire__TI2COperationStatus,
  _swigc__p_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode,
  _swigc__p_mvIMPACT__acquire__TImageBufferPixelFormat,
  _swigc__p_mvIMPACT__acquire__TImageDestinationPixelFormat,
  _swigc__p_mvIMPACT__acquire__TImageProcessingFilter,
  _swigc__p_mvIMPACT__acquire__TImageProcessingMode,
  _swigc__p_mvIMPACT__acquire__TImageProcessingOptimization,
  _swigc__p_mvIMPACT__acquire__TImageProcessingResult,
  _swigc__p_mvIMPACT__acquire__TImageRequestControlMode,
  _swigc__p_mvIMPACT__acquire__TInfoSensorColorMode,
  _swigc__p_mvIMPACT__acquire__TInfoSensorType,
  _swigc__p_mvIMPACT__acquire__TInterlacedMode,
  _swigc__p_mvIMPACT__acquire__TLUTGammaMode,
  _swigc__p_mvIMPACT__acquire__TLUTImplementation,
  _swigc__p_mvIMPACT__acquire__TLUTInterpolationMode,
  _swigc__p_mvIMPACT__acquire__TLUTMapping,
  _swigc__p_mvIMPACT__acquire__TLUTMode,
  _swigc__p_mvIMPACT__acquire__TLineCounter,
  _swigc__p_mvIMPACT__acquire__TMemoryManagerMode,
  _swigc__p_mvIMPACT__acquire__TMemoryManagerPoolMode,
  _swigc__p_mvIMPACT__acquire__TMirrorMode,
  _swigc__p_mvIMPACT__acquire__TMirrorOperationMode,
  _swigc__p_mvIMPACT__acquire__TOnBoardMemoryMode,
  _swigc__p_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode,
  _swigc__p_mvIMPACT__acquire__TPolarizedDataExtractionMode,
  _swigc__p_mvIMPACT__acquire__TPulseStartTrigger,
  _swigc__p_mvIMPACT__acquire__TRTCtrlModes,
  _swigc__p_mvIMPACT__acquire__TRTProgOpCodes,
  _swigc__p_mvIMPACT__acquire__TRequestImageMemoryMode,
  _swigc__p_mvIMPACT__acquire__TRequestResult,
  _swigc__p_mvIMPACT__acquire__TRequestState,
  _swigc__p_mvIMPACT__acquire__TScalerInterpolationMode,
  _swigc__p_mvIMPACT__acquire__TScalerMode,
  _swigc__p_mvIMPACT__acquire__TScanClock,
  _swigc__p_mvIMPACT__acquire__TScanStandard,
  _swigc__p_mvIMPACT__acquire__TThreadPriority,
  _swigc__p_mvIMPACT__acquire__TTriggerMoment,
  _swigc__p_mvIMPACT__acquire__TUserDataAccessRight,
  _swigc__p_mvIMPACT__acquire__TUserDataReconnectBehaviour,
  _swigc__p_mvIMPACT__acquire__TVideoStandard,
  _swigc__p_mvIMPACT__acquire__TVirtualDeviceImageType,
  _swigc__p_mvIMPACT__acquire__TVirtualDeviceTestMode,
  _swigc__p_mvIMPACT__acquire__TWhiteBalanceCalibrationMode,
  _swigc__p_mvIMPACT__acquire__TWhiteBalanceParameter,
  _swigc__p_mvIMPACT__acquire__TriggerControl,
  _swigc__p_mvIMPACT__acquire__UserData,
  _swigc__p_mvIMPACT__acquire__UserDataEntry,
  _swigc__p_mvIMPACT__acquire__WhiteBalanceSettings,
  _swigc__p_p_mvIMPACT__acquire__Request,
  _swigc__p_second_type,
  _swigc__p_std__ios_base__openmode,
  _swigc__p_std__pairT_std__string_double_t,
  _swigc__p_std__pairT_std__string_int_t,
  _swigc__p_std__runtime_error,
  _swigc__p_std__streamsize,
  _swigc__p_std__vectorT_int64_t_t,
  _swigc__p_std__vectorT_mvIMPACT__acquire__Component_t,
  _swigc__p_std__vectorT_std__pairT_std__string_int64_t_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionField_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAcquisitionStartStopBehaviour_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAoiMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoControlMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoControlSpeed_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoExposureControl_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoGainControl_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TAutoOffsetCalibration_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerConversionMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerMosaicParity_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBayerWhiteBalanceResult_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXDigitalInputThreshold_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXFooterMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXInfoSensorCapabilities_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXOffsetAutoBlackSpeed_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXSensorTiming_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBlueFOXTransferSize_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBoolean_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TBufferPartDataType_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraAoiMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraBinningMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraDataFormat_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExposeMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncEdge_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraExternalSyncOutput_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraFlashType_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraHDRMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraInterlacedType_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraLinkDataValidMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraOutput_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraPixelClock_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraScanMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraSerialPortBaudRate_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraShutterMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsXGeometry_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTapsYGeometry_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTestMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TCameraTriggerSource_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TChannelSplitMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TClampMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorProcessingMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorTwistInputCorrectionMatrixMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TColorTwistOutputCorrectionMatrixMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDarkCurrentFilterMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDefectivePixelsFilterMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceAccessMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceAdvancedOptions_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceCapability_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceClass_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceDigitalOutputMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceEventMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceEventType_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceImageTrigger_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceInterfaceLayout_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceLoadSettings_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDevicePowerMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceScanRateMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceSignalOutputStartEvent_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceState_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceSyncOutMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerInterface_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDeviceTriggerOverlap_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigIOState_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalIOMeasurementSource_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalOutputControlMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TDigitalSignal_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFieldGateMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterCorrectionMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TFlatFieldFilterMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__THWUpdateResult_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TI2COperationMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TI2COperationStatus_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageBufferFormatReinterpreterMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageBufferPixelFormat_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageDestinationPixelFormat_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingFilter_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingOptimization_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageProcessingResult_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TImageRequestControlMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorColorMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInfoSensorType_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TInterlacedMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTGammaMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTImplementation_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTInterpolationMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTMapping_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLUTMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TLineCounter_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMemoryManagerPoolMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMirrorMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TMirrorOperationMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TOnBoardMemoryMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionInterpolationMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPolarizedDataExtractionMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TPulseStartTrigger_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRTCtrlModes_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRTProgOpCodes_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestImageMemoryMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestResult_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TRequestState_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScalerInterpolationMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScalerMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScanClock_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TScanStandard_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TThreadPriority_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TTriggerMoment_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TUserDataAccessRight_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TUserDataReconnectBehaviour_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVideoStandard_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceImageType_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TVirtualDeviceTestMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceCalibrationMode_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_mvIMPACT__acquire__TWhiteBalanceParameter_t_t,
  _swigc__p_std__vectorT_std__string_t,
  _swigc__p_std__vectorT_void_p_t,
  _swigc__p_uint16_t,
  _swigc__p_uint32_t,
  _swigc__p_uint64_t,
  _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 staticly 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 found, init;
  
  clientdata = clientdata;
  
  /* 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);
    module_head = &swig_module;
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    found=0;
    iter=module_head;
    do {
      if (iter==&swig_module) {
        found=1;
        break;
      }
      iter=iter->next;
    } while (iter!= module_head);
    
    /* if the is found in the list, then all is done and we may leave */
    if (found) return;
    /* otherwise we must add out module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }
  
  /* When multiple interpeters 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 %d\n", 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 %d %s\n", 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 %d %s\n", 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 int
  swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
    char *tmp;
    PyObject *str = swig_varlink_str(v);
    fprintf(fp,"Swig global variables ");
    fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
    SWIG_Python_str_DelForPy3(tmp);
    Py_DECREF(str);
    return 0;
  }
  
  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_SetString(PyExc_NameError,"Unknown C global variable");
    }
    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_SetString(PyExc_NameError,"Unknown C global variable");
    }
    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
      = {
        /* PyObject header changed in Python 3 */
#if PY_VERSION_HEX >= 0x03000000
        PyVarObject_HEAD_INIT(&PyType_Type, 0)
#else
        PyObject_HEAD_INIT(NULL)
        0,                                  /* Number of items in variable part (ob_size) */
#endif
        (char *)"swigvarlink",              /* Type name (tp_name) */
        sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
        0,                                  /* Itemsize (tp_itemsize) */
        (destructor) swig_varlink_dealloc,  /* Deallocator (tp_dealloc) */ 
        (printfunc) swig_varlink_print,     /* Print (tp_print) */
        (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
        (setattrfunc) swig_varlink_setattr, /* Set attr (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 */
#if PY_VERSION_HEX >= 0x02020000
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
#endif
#if PY_VERSION_HEX >= 0x02030000
        0,                                  /* tp_del */
#endif
#ifdef COUNT_ALLOCS
        0,0,0,0                             /* tp_alloc -> tp_next */
#endif
      };
      varlink_type = tmp;
      /* for Python 3 we already assigned ob_type in PyVarObject_HEAD_INIT() */
#if PY_VERSION_HEX < 0x03000000
      varlink_type.ob_type = &PyType_Type;
#endif
      type_init = 1;
    }
    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, 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) {
        strncpy(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 *_SWIG_globals = 0; 
    if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();  
    return _SWIG_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_NewPointerObj(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 && (c = strstr(c, "swig_ptr: "))) {
        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;
              strncpy(buff, methods[i].ml_doc, ldoc);
              buff += ldoc;
              strncpy(buff, "swig_ptr: ", 10);
              buff += 10;
              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
              methods[i].ml_doc = ndoc;
            }
          }
        }
      }
    }
  } 
  
#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;  
#if PY_VERSION_HEX >= 0x03000000
  static struct PyModuleDef SWIG_module = {
    PyModuleDef_HEAD_INIT,
    (char *) SWIG_name,
    NULL,
    -1,
    SwigMethods,
    NULL,
    NULL,
    NULL,
    NULL
  };
#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((char *) SWIG_name, SwigMethods);
#endif
  d = PyModule_GetDict(m);
  
  SWIG_InitializeModule(0);
  SWIG_InstallConstants(d,swig_const_table);
  
  
  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 >(30)));
  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 >(2581)));
  SWIG_Python_SetConstant(d, "MVIMPACT_ACQUIRE_VERSION_STRING",SWIG_FromCharPtr("2.30.1.2581"));
  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, "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, "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, "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, "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, "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, "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, "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, "demIgnore",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::demIgnore)));
  SWIG_Python_SetConstant(d, "demNotify",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::demNotify)));
  SWIG_Python_SetConstant(d, "detNone",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::detNone)));
  SWIG_Python_SetConstant(d, "detPnPArrival",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::detPnPArrival)));
  SWIG_Python_SetConstant(d, "detPnPRemoval",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::detPnPRemoval)));
  SWIG_Python_SetConstant(d, "detFrameStart",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::detFrameStart)));
  SWIG_Python_SetConstant(d, "detHistogramReady",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::detHistogramReady)));
  SWIG_Python_SetConstant(d, "detAll",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::detAll)));
  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_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, "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, "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, "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_RGB101010Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibfrmMono10_To_RGB101010Packed)));
  SWIG_Python_SetConstant(d, "ibfrmMono12_To_RGB121212Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibfrmMono12_To_RGB121212Packed)));
  SWIG_Python_SetConstant(d, "ibfrmMono14_To_RGB141414Packed",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::ibfrmMono14_To_RGB141414Packed)));
  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, "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, "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, "tpIdle",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::tpIdle)));
  SWIG_Python_SetConstant(d, "tpLowest",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::tpLowest)));
  SWIG_Python_SetConstant(d, "tpBelowNormal",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::tpBelowNormal)));
  SWIG_Python_SetConstant(d, "tpNormal",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::tpNormal)));
  SWIG_Python_SetConstant(d, "tpAboveNormal",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::tpAboveNormal)));
  SWIG_Python_SetConstant(d, "tpHighest",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::tpHighest)));
  SWIG_Python_SetConstant(d, "tpTimeCritical",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::tpTimeCritical)));
  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, "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, "vdtmColdPixelTestImageBayer",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::vdtmColdPixelTestImageBayer)));
  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)));
  PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
  SWIG_addvarlink(SWIG_globals(),(char*)"INVALID_ID",Swig_var_INVALID_ID_get, Swig_var_INVALID_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PROP_MAX_VAL",Swig_var_PROP_MAX_VAL_get, Swig_var_PROP_MAX_VAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PROP_MIN_VAL",Swig_var_PROP_MIN_VAL_get, Swig_var_PROP_MIN_VAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PROP_STEP_WIDTH",Swig_var_PROP_STEP_WIDTH_get, Swig_var_PROP_STEP_WIDTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PROP_DEFAULT_VALUE",Swig_var_PROP_DEFAULT_VALUE_get, Swig_var_PROP_DEFAULT_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PROP_MAX_BINARY_BUFFER_SIZE",Swig_var_PROP_MAX_BINARY_BUFFER_SIZE_get, Swig_var_PROP_MAX_BINARY_BUFFER_SIZE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PROP_LAST_CONSTANT",Swig_var_PROP_LAST_CONSTANT_get, Swig_var_PROP_LAST_CONSTANT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DEFAULT_STRING_SIZE_LIMIT",Swig_var_DEFAULT_STRING_SIZE_LIMIT_get, Swig_var_DEFAULT_STRING_SIZE_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ROOT_LIST",Swig_var_ROOT_LIST_get, Swig_var_ROOT_LIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"END_OF_LIST",Swig_var_END_OF_LIST_get, Swig_var_END_OF_LIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"smIgnoreLists",Swig_var_smIgnoreLists_get, Swig_var_smIgnoreLists_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"smIgnoreMethods",Swig_var_smIgnoreMethods_get, Swig_var_smIgnoreMethods_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"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, "cfLast",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::cfLast)));
  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_PSEUDO_LAST_ASSIGNED_ERROR_CODE",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_PSEUDO_LAST_ASSIGNED_ERROR_CODE)));
  SWIG_Python_SetConstant(d, "PROPHANDLING_LAST_ASSIGNED_ERROR_CODE",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::PROPHANDLING_LAST_ASSIGNED_ERROR_CODE)));
  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, "sfReserved1",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::sfReserved1)));
  SWIG_Python_SetConstant(d, "sfReserved2",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::sfReserved2)));
  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, "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, "dltEventSubSystemSettings",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dltEventSubSystemSettings)));
  SWIG_Python_SetConstant(d, "dltEventSubSystemResults",SWIG_From_int(static_cast< int >(mvIMPACT::acquire::dltEventSubSystemResults)));
  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)));
  
  /* Initialize threading */
  SWIG_PYTHON_INITIALIZE_THREADS;
#if PY_VERSION_HEX >= 0x03000000
  return m;
#else
  return;
#endif
}

