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


#define SWIG_VERSION 0x040400
#define SWIGJAVA

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#if defined(__cplusplus) && __cplusplus >=201103L
# define SWIG_NOEXCEPT noexcept
#else
# define SWIG_NOEXCEPT throw()
#endif 

/* -----------------------------------------------------------------------------
 * swigcompat.swg
 *
 * Macros to provide support compatibility with older C and C++ standards.
 *
 * Note that SWIG expects __cplusplus to be defined to the appropriate C++ standard.
 * MSVC users are urged to check and examine the /Zc:__cplusplus compiler option.
 * See https://learn.microsoft.com/en-us/cpp/build/reference/zc-cplusplus.
 * ----------------------------------------------------------------------------- */

/* C99 and C++11 should provide snprintf, but define SWIG_NO_SNPRINTF
 * if you're missing it.
 */
#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \
     (defined __cplusplus && __cplusplus >= 201103L) || \
     defined SWIG_HAVE_SNPRINTF) && \
    !defined SWIG_NO_SNPRINTF
# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A)
# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B)
#else
/* Fallback versions ignore the buffer size, but most of our uses either have a
 * fixed maximum possible size or dynamically allocate a buffer that's large
 * enough.
 */
# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A)
# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B)
#endif


#include <jni.h>
#include <stdlib.h>
#include <string.h>


/* Support for throwing Java exceptions */
typedef enum {
  SWIG_JavaOutOfMemoryError = 1,
  SWIG_JavaIOException,
  SWIG_JavaRuntimeException,
  SWIG_JavaIndexOutOfBoundsException,
  SWIG_JavaArithmeticException,
  SWIG_JavaIllegalArgumentException,
  SWIG_JavaNullPointerException,
  SWIG_JavaDirectorPureVirtual,
  SWIG_JavaUnknownError,
  SWIG_JavaIllegalStateException,
} SWIG_JavaExceptionCodes;

typedef struct {
  SWIG_JavaExceptionCodes code;
  const char *java_exception;
} SWIG_JavaExceptions_t;


static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) {
  jclass excep;
  static const SWIG_JavaExceptions_t java_exceptions[] = {
    { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" },
    { SWIG_JavaIOException, "java/io/IOException" },
    { SWIG_JavaRuntimeException, "java/lang/RuntimeException" },
    { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" },
    { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" },
    { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" },
    { SWIG_JavaNullPointerException, "java/lang/NullPointerException" },
    { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" },
    { SWIG_JavaUnknownError,  "java/lang/UnknownError" },
    { SWIG_JavaIllegalStateException, "java/lang/IllegalStateException" },
    { (SWIG_JavaExceptionCodes)0,  "java/lang/UnknownError" }
  };
  const SWIG_JavaExceptions_t *except_ptr = java_exceptions;

  while (except_ptr->code != code && except_ptr->code)
    except_ptr++;

  jenv->ExceptionClear();
  excep = jenv->FindClass(except_ptr->java_exception);
  if (excep)
    jenv->ThrowNew(excep, msg);
}


/* Contract support */

#define SWIG_contract_assert(nullreturn, expr, msg) do { if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } } while (0)

/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
#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



#ifdef __cplusplus
#include <utility>
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigSmartPointer {
    T *ptr;
    SwigSmartPointer(T *p) : ptr(p) { }
    ~SwigSmartPointer() { delete ptr; }
    SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
    void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; }
#if __cplusplus >=201103L
  SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; }
  operator T&&() const { return std::move(*pointer.ptr); }
#else
  operator T&() const { return *pointer.ptr; }
#endif
  T *operator&() const { return pointer.ptr; }
  static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); }
};

/*
 * SwigValueInit() is a generic initialisation solution as the following approach:
 * 
 *       T c_result = T();
 * 
 * doesn't compile for all types for example:
 * 
 *       unsigned int c_result = unsigned int();
 */
template <typename T> T SwigValueInit() {
  return T();
}

#if __cplusplus >=201103L
# define SWIG_STD_MOVE(OBJ) std::move(OBJ)
#else
# define SWIG_STD_MOVE(OBJ) OBJ
#endif

#endif


#include <libsigrokcxx/libsigrokcxx.hpp>
using namespace std;


#include <string>


#include <typeinfo>
#include <stdexcept>


#include <vector>
#include <stdexcept>


#include <map>
#include <stdexcept>

SWIGINTERN std::map< std::string,std::string,std::less< std::string > >::iterator std_map_Sl_std_string_Sc_std_string_Sg__iterator_getNextUnchecked(std::map< std::string,std::string >::iterator *self){
          std::map< std::string, std::string, std::less< std::string > >::iterator copy = (*self);
          return ++copy;
        }
SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg__iterator_isNot(std::map< std::string,std::string >::iterator const *self,std::map< std::string,std::string >::iterator other){
          return (*self != other);
        }
SWIGINTERN std::string std_map_Sl_std_string_Sc_std_string_Sg__iterator_getKey(std::map< std::string,std::string >::iterator const *self){
          return (*self)->first;
        }
SWIGINTERN std::string std_map_Sl_std_string_Sc_std_string_Sg__iterator_getValue(std::map< std::string,std::string >::iterator const *self){
          return (*self)->second;
        }
SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg__iterator_setValue(std::map< std::string,std::string >::iterator *self,std::string const &newValue){
          (*self)->second = newValue;
        }

/* Check for overflow converting to Java int (always signed 32-bit) from (unsigned variable-bit) size_t */
SWIGINTERN jint SWIG_JavaIntFromSize_t(size_t size) {
  static const jint JINT_MAX = 0x7FFFFFFF;
  return (size > (size_t)JINT_MAX) ? -1 : (jint)size;
}


  SWIGINTERN jint SWIG_MapSize(size_t size) {
    jint sz = SWIG_JavaIntFromSize_t(size);
    if (sz == -1) {
      throw std::out_of_range("map size is too large to fit into a Java int");
    }

    return sz;
  }

SWIGINTERN jint std_map_Sl_std_string_Sc_std_string_Sg__sizeImpl(std::map< std::string,std::string > const *self){
        return SWIG_MapSize(self->size());
      }
SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg__containsImpl(std::map< std::string,std::string > *self,std::string const &key){
        return (self->count(key) > 0);
      }
SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg__putUnchecked(std::map< std::string,std::string > *self,std::string const &key,std::string const &value){
#ifdef __cpp_lib_map_try_emplace
        (*self).insert_or_assign(key, value);
#else
        (*self)[key] = value;
#endif
      }
SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg__removeUnchecked(std::map< std::string,std::string > *self,std::map< std::string,std::string,std::less< std::string > >::iterator const itr){
        self->erase(itr);
      }
SWIGINTERN std::map< std::string,std::shared_ptr< sigrok::Driver >,std::less< std::string > >::iterator std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Driver_Sg__Sg__iterator_getNextUnchecked(std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator *self){
          std::map< std::string, std::shared_ptr< sigrok::Driver >, std::less< std::string > >::iterator copy = (*self);
          return ++copy;
        }
SWIGINTERN bool std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Driver_Sg__Sg__iterator_isNot(std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator const *self,std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator other){
          return (*self != other);
        }
SWIGINTERN std::string std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Driver_Sg__Sg__iterator_getKey(std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator const *self){
          return (*self)->first;
        }
SWIGINTERN std::shared_ptr< sigrok::Driver > std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Driver_Sg__Sg__iterator_getValue(std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator const *self){
          return (*self)->second;
        }
SWIGINTERN void std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Driver_Sg__Sg__iterator_setValue(std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator *self,std::shared_ptr< sigrok::Driver > const &newValue){
          (*self)->second = newValue;
        }
SWIGINTERN jint std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Driver_Sg__Sg__sizeImpl(std::map< std::string,std::shared_ptr< sigrok::Driver > > const *self){
        return SWIG_MapSize(self->size());
      }
SWIGINTERN bool std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Driver_Sg__Sg__containsImpl(std::map< std::string,std::shared_ptr< sigrok::Driver > > *self,std::string const &key){
        return (self->count(key) > 0);
      }
SWIGINTERN void std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Driver_Sg__Sg__putUnchecked(std::map< std::string,std::shared_ptr< sigrok::Driver > > *self,std::string const &key,std::shared_ptr< sigrok::Driver > const &value){
#ifdef __cpp_lib_map_try_emplace
        (*self).insert_or_assign(key, value);
#else
        (*self)[key] = value;
#endif
      }
SWIGINTERN void std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Driver_Sg__Sg__removeUnchecked(std::map< std::string,std::shared_ptr< sigrok::Driver > > *self,std::map< std::string,std::shared_ptr< sigrok::Driver >,std::less< std::string > >::iterator const itr){
        self->erase(itr);
      }
SWIGINTERN std::map< std::string,std::shared_ptr< sigrok::InputFormat >,std::less< std::string > >::iterator std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_InputFormat_Sg__Sg__iterator_getNextUnchecked(std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator *self){
          std::map< std::string, std::shared_ptr< sigrok::InputFormat >, std::less< std::string > >::iterator copy = (*self);
          return ++copy;
        }
SWIGINTERN bool std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_InputFormat_Sg__Sg__iterator_isNot(std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator const *self,std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator other){
          return (*self != other);
        }
SWIGINTERN std::string std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_InputFormat_Sg__Sg__iterator_getKey(std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator const *self){
          return (*self)->first;
        }
SWIGINTERN std::shared_ptr< sigrok::InputFormat > std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_InputFormat_Sg__Sg__iterator_getValue(std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator const *self){
          return (*self)->second;
        }
SWIGINTERN void std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_InputFormat_Sg__Sg__iterator_setValue(std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator *self,std::shared_ptr< sigrok::InputFormat > const &newValue){
          (*self)->second = newValue;
        }
SWIGINTERN jint std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_InputFormat_Sg__Sg__sizeImpl(std::map< std::string,std::shared_ptr< sigrok::InputFormat > > const *self){
        return SWIG_MapSize(self->size());
      }
SWIGINTERN bool std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_InputFormat_Sg__Sg__containsImpl(std::map< std::string,std::shared_ptr< sigrok::InputFormat > > *self,std::string const &key){
        return (self->count(key) > 0);
      }
SWIGINTERN void std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_InputFormat_Sg__Sg__putUnchecked(std::map< std::string,std::shared_ptr< sigrok::InputFormat > > *self,std::string const &key,std::shared_ptr< sigrok::InputFormat > const &value){
#ifdef __cpp_lib_map_try_emplace
        (*self).insert_or_assign(key, value);
#else
        (*self)[key] = value;
#endif
      }
SWIGINTERN void std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_InputFormat_Sg__Sg__removeUnchecked(std::map< std::string,std::shared_ptr< sigrok::InputFormat > > *self,std::map< std::string,std::shared_ptr< sigrok::InputFormat >,std::less< std::string > >::iterator const itr){
        self->erase(itr);
      }
SWIGINTERN std::map< std::string,std::shared_ptr< sigrok::OutputFormat >,std::less< std::string > >::iterator std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_OutputFormat_Sg__Sg__iterator_getNextUnchecked(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator *self){
          std::map< std::string, std::shared_ptr< sigrok::OutputFormat >, std::less< std::string > >::iterator copy = (*self);
          return ++copy;
        }
SWIGINTERN bool std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_OutputFormat_Sg__Sg__iterator_isNot(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator const *self,std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator other){
          return (*self != other);
        }
SWIGINTERN std::string std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_OutputFormat_Sg__Sg__iterator_getKey(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator const *self){
          return (*self)->first;
        }
SWIGINTERN std::shared_ptr< sigrok::OutputFormat > std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_OutputFormat_Sg__Sg__iterator_getValue(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator const *self){
          return (*self)->second;
        }
SWIGINTERN void std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_OutputFormat_Sg__Sg__iterator_setValue(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator *self,std::shared_ptr< sigrok::OutputFormat > const &newValue){
          (*self)->second = newValue;
        }
SWIGINTERN jint std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_OutputFormat_Sg__Sg__sizeImpl(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > const *self){
        return SWIG_MapSize(self->size());
      }
SWIGINTERN bool std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_OutputFormat_Sg__Sg__containsImpl(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > *self,std::string const &key){
        return (self->count(key) > 0);
      }
SWIGINTERN void std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_OutputFormat_Sg__Sg__putUnchecked(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > *self,std::string const &key,std::shared_ptr< sigrok::OutputFormat > const &value){
#ifdef __cpp_lib_map_try_emplace
        (*self).insert_or_assign(key, value);
#else
        (*self)[key] = value;
#endif
      }
SWIGINTERN void std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_OutputFormat_Sg__Sg__removeUnchecked(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > *self,std::map< std::string,std::shared_ptr< sigrok::OutputFormat >,std::less< std::string > >::iterator const itr){
        self->erase(itr);
      }

SWIGINTERN jint SWIG_VectorSize(size_t size) {
  jint sz = SWIG_JavaIntFromSize_t(size);
  if (sz == -1)
    throw std::out_of_range("vector size is too large to fit into a Java int");
  return sz;
}

SWIGINTERN std::vector< std::shared_ptr< sigrok::HardwareDevice > > *new_std_vector_Sl_std_shared_ptr_Sl_sigrok_HardwareDevice_Sg__Sg___SWIG_2(jint count,std::shared_ptr< sigrok::HardwareDevice > const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< std::shared_ptr< sigrok::HardwareDevice > >(static_cast<std::vector< std::shared_ptr< sigrok::HardwareDevice > >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_std_shared_ptr_Sl_sigrok_HardwareDevice_Sg__Sg__doCapacity(std::vector< std::shared_ptr< sigrok::HardwareDevice > > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_HardwareDevice_Sg__Sg__doReserve(std::vector< std::shared_ptr< sigrok::HardwareDevice > > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_std_shared_ptr_Sl_sigrok_HardwareDevice_Sg__Sg__doSize(std::vector< std::shared_ptr< sigrok::HardwareDevice > > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_HardwareDevice_Sg__Sg__doAdd__SWIG_0(std::vector< std::shared_ptr< sigrok::HardwareDevice > > *self,std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_HardwareDevice_Sg__Sg__doAdd__SWIG_1(std::vector< std::shared_ptr< sigrok::HardwareDevice > > *self,jint index,std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type std_vector_Sl_std_shared_ptr_Sl_sigrok_HardwareDevice_Sg__Sg__doRemove(std::vector< std::shared_ptr< sigrok::HardwareDevice > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          std::shared_ptr< sigrok::HardwareDevice > const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type const &std_vector_Sl_std_shared_ptr_Sl_sigrok_HardwareDevice_Sg__Sg__doGet(std::vector< std::shared_ptr< sigrok::HardwareDevice > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type std_vector_Sl_std_shared_ptr_Sl_sigrok_HardwareDevice_Sg__Sg__doSet(std::vector< std::shared_ptr< sigrok::HardwareDevice > > *self,jint index,std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          std::shared_ptr< sigrok::HardwareDevice > const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_HardwareDevice_Sg__Sg__doRemoveRange(std::vector< std::shared_ptr< sigrok::HardwareDevice > > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::shared_ptr< sigrok::Device > > *new_std_vector_Sl_std_shared_ptr_Sl_sigrok_Device_Sg__Sg___SWIG_2(jint count,std::shared_ptr< sigrok::Device > const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< std::shared_ptr< sigrok::Device > >(static_cast<std::vector< std::shared_ptr< sigrok::Device > >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_std_shared_ptr_Sl_sigrok_Device_Sg__Sg__doCapacity(std::vector< std::shared_ptr< sigrok::Device > > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_Device_Sg__Sg__doReserve(std::vector< std::shared_ptr< sigrok::Device > > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_std_shared_ptr_Sl_sigrok_Device_Sg__Sg__doSize(std::vector< std::shared_ptr< sigrok::Device > > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_Device_Sg__Sg__doAdd__SWIG_0(std::vector< std::shared_ptr< sigrok::Device > > *self,std::vector< std::shared_ptr< sigrok::Device > >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_Device_Sg__Sg__doAdd__SWIG_1(std::vector< std::shared_ptr< sigrok::Device > > *self,jint index,std::vector< std::shared_ptr< sigrok::Device > >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::shared_ptr< sigrok::Device > >::value_type std_vector_Sl_std_shared_ptr_Sl_sigrok_Device_Sg__Sg__doRemove(std::vector< std::shared_ptr< sigrok::Device > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          std::shared_ptr< sigrok::Device > const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::shared_ptr< sigrok::Device > >::value_type const &std_vector_Sl_std_shared_ptr_Sl_sigrok_Device_Sg__Sg__doGet(std::vector< std::shared_ptr< sigrok::Device > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< std::shared_ptr< sigrok::Device > >::value_type std_vector_Sl_std_shared_ptr_Sl_sigrok_Device_Sg__Sg__doSet(std::vector< std::shared_ptr< sigrok::Device > > *self,jint index,std::vector< std::shared_ptr< sigrok::Device > >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          std::shared_ptr< sigrok::Device > const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_Device_Sg__Sg__doRemoveRange(std::vector< std::shared_ptr< sigrok::Device > > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::shared_ptr< sigrok::Channel > > *new_std_vector_Sl_std_shared_ptr_Sl_sigrok_Channel_Sg__Sg___SWIG_2(jint count,std::shared_ptr< sigrok::Channel > const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< std::shared_ptr< sigrok::Channel > >(static_cast<std::vector< std::shared_ptr< sigrok::Channel > >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_std_shared_ptr_Sl_sigrok_Channel_Sg__Sg__doCapacity(std::vector< std::shared_ptr< sigrok::Channel > > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_Channel_Sg__Sg__doReserve(std::vector< std::shared_ptr< sigrok::Channel > > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_std_shared_ptr_Sl_sigrok_Channel_Sg__Sg__doSize(std::vector< std::shared_ptr< sigrok::Channel > > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_Channel_Sg__Sg__doAdd__SWIG_0(std::vector< std::shared_ptr< sigrok::Channel > > *self,std::vector< std::shared_ptr< sigrok::Channel > >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_Channel_Sg__Sg__doAdd__SWIG_1(std::vector< std::shared_ptr< sigrok::Channel > > *self,jint index,std::vector< std::shared_ptr< sigrok::Channel > >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::shared_ptr< sigrok::Channel > >::value_type std_vector_Sl_std_shared_ptr_Sl_sigrok_Channel_Sg__Sg__doRemove(std::vector< std::shared_ptr< sigrok::Channel > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          std::shared_ptr< sigrok::Channel > const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::shared_ptr< sigrok::Channel > >::value_type const &std_vector_Sl_std_shared_ptr_Sl_sigrok_Channel_Sg__Sg__doGet(std::vector< std::shared_ptr< sigrok::Channel > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< std::shared_ptr< sigrok::Channel > >::value_type std_vector_Sl_std_shared_ptr_Sl_sigrok_Channel_Sg__Sg__doSet(std::vector< std::shared_ptr< sigrok::Channel > > *self,jint index,std::vector< std::shared_ptr< sigrok::Channel > >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          std::shared_ptr< sigrok::Channel > const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_Channel_Sg__Sg__doRemoveRange(std::vector< std::shared_ptr< sigrok::Channel > > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::map< std::string,std::shared_ptr< sigrok::ChannelGroup >,std::less< std::string > >::iterator std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_ChannelGroup_Sg__Sg__iterator_getNextUnchecked(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator *self){
          std::map< std::string, std::shared_ptr< sigrok::ChannelGroup >, std::less< std::string > >::iterator copy = (*self);
          return ++copy;
        }
SWIGINTERN bool std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_ChannelGroup_Sg__Sg__iterator_isNot(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator const *self,std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator other){
          return (*self != other);
        }
SWIGINTERN std::string std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_ChannelGroup_Sg__Sg__iterator_getKey(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator const *self){
          return (*self)->first;
        }
SWIGINTERN std::shared_ptr< sigrok::ChannelGroup > std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_ChannelGroup_Sg__Sg__iterator_getValue(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator const *self){
          return (*self)->second;
        }
SWIGINTERN void std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_ChannelGroup_Sg__Sg__iterator_setValue(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator *self,std::shared_ptr< sigrok::ChannelGroup > const &newValue){
          (*self)->second = newValue;
        }
SWIGINTERN jint std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_ChannelGroup_Sg__Sg__sizeImpl(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > const *self){
        return SWIG_MapSize(self->size());
      }
SWIGINTERN bool std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_ChannelGroup_Sg__Sg__containsImpl(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > *self,std::string const &key){
        return (self->count(key) > 0);
      }
SWIGINTERN void std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_ChannelGroup_Sg__Sg__putUnchecked(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > *self,std::string const &key,std::shared_ptr< sigrok::ChannelGroup > const &value){
#ifdef __cpp_lib_map_try_emplace
        (*self).insert_or_assign(key, value);
#else
        (*self)[key] = value;
#endif
      }
SWIGINTERN void std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_ChannelGroup_Sg__Sg__removeUnchecked(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > *self,std::map< std::string,std::shared_ptr< sigrok::ChannelGroup >,std::less< std::string > >::iterator const itr){
        self->erase(itr);
      }
SWIGINTERN std::vector< sigrok::ConfigKey const * > *new_std_vector_Sl_sigrok_ConfigKey_SS_const_Sm__Sg___SWIG_2(jint count,sigrok::ConfigKey const *const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< sigrok::ConfigKey const * >(static_cast<std::vector< sigrok::ConfigKey const * >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_sigrok_ConfigKey_SS_const_Sm__Sg__doCapacity(std::vector< sigrok::ConfigKey const * > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_sigrok_ConfigKey_SS_const_Sm__Sg__doReserve(std::vector< sigrok::ConfigKey const * > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_sigrok_ConfigKey_SS_const_Sm__Sg__doSize(std::vector< sigrok::ConfigKey const * > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_sigrok_ConfigKey_SS_const_Sm__Sg__doAdd__SWIG_0(std::vector< sigrok::ConfigKey const * > *self,std::vector< sigrok::ConfigKey const * >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_sigrok_ConfigKey_SS_const_Sm__Sg__doAdd__SWIG_1(std::vector< sigrok::ConfigKey const * > *self,jint index,std::vector< sigrok::ConfigKey const * >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< sigrok::ConfigKey const * >::value_type std_vector_Sl_sigrok_ConfigKey_SS_const_Sm__Sg__doRemove(std::vector< sigrok::ConfigKey const * > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          sigrok::ConfigKey const * const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< sigrok::ConfigKey const * >::value_type const &std_vector_Sl_sigrok_ConfigKey_SS_const_Sm__Sg__doGet(std::vector< sigrok::ConfigKey const * > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< sigrok::ConfigKey const * >::value_type std_vector_Sl_sigrok_ConfigKey_SS_const_Sm__Sg__doSet(std::vector< sigrok::ConfigKey const * > *self,jint index,std::vector< sigrok::ConfigKey const * >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          sigrok::ConfigKey const * const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_sigrok_ConfigKey_SS_const_Sm__Sg__doRemoveRange(std::vector< sigrok::ConfigKey const * > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::map< sigrok::ConfigKey const *,Glib::VariantBase,std::less< sigrok::ConfigKey const * > >::iterator std_map_Sl_sigrok_ConfigKey_SS_const_Sm__Sc_Glib_VariantBase_Sg__iterator_getNextUnchecked(std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator *self){
          std::map< sigrok::ConfigKey const *, Glib::VariantBase, std::less< sigrok::ConfigKey const * > >::iterator copy = (*self);
          return ++copy;
        }
SWIGINTERN bool std_map_Sl_sigrok_ConfigKey_SS_const_Sm__Sc_Glib_VariantBase_Sg__iterator_isNot(std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator const *self,std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator other){
          return (*self != other);
        }
SWIGINTERN sigrok::ConfigKey const *std_map_Sl_sigrok_ConfigKey_SS_const_Sm__Sc_Glib_VariantBase_Sg__iterator_getKey(std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator const *self){
          return (*self)->first;
        }
SWIGINTERN Glib::VariantBase std_map_Sl_sigrok_ConfigKey_SS_const_Sm__Sc_Glib_VariantBase_Sg__iterator_getValue(std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator const *self){
          return (*self)->second;
        }
SWIGINTERN void std_map_Sl_sigrok_ConfigKey_SS_const_Sm__Sc_Glib_VariantBase_Sg__iterator_setValue(std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator *self,Glib::VariantBase const &newValue){
          (*self)->second = newValue;
        }
SWIGINTERN jint std_map_Sl_sigrok_ConfigKey_SS_const_Sm__Sc_Glib_VariantBase_Sg__sizeImpl(std::map< sigrok::ConfigKey const *,Glib::VariantBase > const *self){
        return SWIG_MapSize(self->size());
      }
SWIGINTERN bool std_map_Sl_sigrok_ConfigKey_SS_const_Sm__Sc_Glib_VariantBase_Sg__containsImpl(std::map< sigrok::ConfigKey const *,Glib::VariantBase > *self,sigrok::ConfigKey const *const &key){
        return (self->count(key) > 0);
      }
SWIGINTERN void std_map_Sl_sigrok_ConfigKey_SS_const_Sm__Sc_Glib_VariantBase_Sg__putUnchecked(std::map< sigrok::ConfigKey const *,Glib::VariantBase > *self,sigrok::ConfigKey const *const &key,Glib::VariantBase const &value){
#ifdef __cpp_lib_map_try_emplace
        (*self).insert_or_assign(key, value);
#else
        (*self)[key] = value;
#endif
      }
SWIGINTERN void std_map_Sl_sigrok_ConfigKey_SS_const_Sm__Sc_Glib_VariantBase_Sg__removeUnchecked(std::map< sigrok::ConfigKey const *,Glib::VariantBase > *self,std::map< sigrok::ConfigKey const *,Glib::VariantBase,std::less< sigrok::ConfigKey const * > >::iterator const itr){
        self->erase(itr);
      }
SWIGINTERN std::vector< sigrok::Capability const * > *new_std_vector_Sl_sigrok_Capability_SS_const_Sm__Sg___SWIG_2(jint count,sigrok::Capability const *const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< sigrok::Capability const * >(static_cast<std::vector< sigrok::Capability const * >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_sigrok_Capability_SS_const_Sm__Sg__doCapacity(std::vector< sigrok::Capability const * > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_sigrok_Capability_SS_const_Sm__Sg__doReserve(std::vector< sigrok::Capability const * > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_sigrok_Capability_SS_const_Sm__Sg__doSize(std::vector< sigrok::Capability const * > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_sigrok_Capability_SS_const_Sm__Sg__doAdd__SWIG_0(std::vector< sigrok::Capability const * > *self,std::vector< sigrok::Capability const * >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_sigrok_Capability_SS_const_Sm__Sg__doAdd__SWIG_1(std::vector< sigrok::Capability const * > *self,jint index,std::vector< sigrok::Capability const * >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< sigrok::Capability const * >::value_type std_vector_Sl_sigrok_Capability_SS_const_Sm__Sg__doRemove(std::vector< sigrok::Capability const * > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          sigrok::Capability const * const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< sigrok::Capability const * >::value_type const &std_vector_Sl_sigrok_Capability_SS_const_Sm__Sg__doGet(std::vector< sigrok::Capability const * > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< sigrok::Capability const * >::value_type std_vector_Sl_sigrok_Capability_SS_const_Sm__Sg__doSet(std::vector< sigrok::Capability const * > *self,jint index,std::vector< sigrok::Capability const * >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          sigrok::Capability const * const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_sigrok_Capability_SS_const_Sm__Sg__doRemoveRange(std::vector< sigrok::Capability const * > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::shared_ptr< sigrok::Option > > *new_std_vector_Sl_std_shared_ptr_Sl_sigrok_Option_Sg__Sg___SWIG_2(jint count,std::shared_ptr< sigrok::Option > const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< std::shared_ptr< sigrok::Option > >(static_cast<std::vector< std::shared_ptr< sigrok::Option > >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__doCapacity(std::vector< std::shared_ptr< sigrok::Option > > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__doReserve(std::vector< std::shared_ptr< sigrok::Option > > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__doSize(std::vector< std::shared_ptr< sigrok::Option > > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__doAdd__SWIG_0(std::vector< std::shared_ptr< sigrok::Option > > *self,std::vector< std::shared_ptr< sigrok::Option > >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__doAdd__SWIG_1(std::vector< std::shared_ptr< sigrok::Option > > *self,jint index,std::vector< std::shared_ptr< sigrok::Option > >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::shared_ptr< sigrok::Option > >::value_type std_vector_Sl_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__doRemove(std::vector< std::shared_ptr< sigrok::Option > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          std::shared_ptr< sigrok::Option > const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::shared_ptr< sigrok::Option > >::value_type const &std_vector_Sl_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__doGet(std::vector< std::shared_ptr< sigrok::Option > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< std::shared_ptr< sigrok::Option > >::value_type std_vector_Sl_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__doSet(std::vector< std::shared_ptr< sigrok::Option > > *self,jint index,std::vector< std::shared_ptr< sigrok::Option > >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          std::shared_ptr< sigrok::Option > const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__doRemoveRange(std::vector< std::shared_ptr< sigrok::Option > > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::map< std::string,std::shared_ptr< sigrok::Option >,std::less< std::string > >::iterator std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__iterator_getNextUnchecked(std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator *self){
          std::map< std::string, std::shared_ptr< sigrok::Option >, std::less< std::string > >::iterator copy = (*self);
          return ++copy;
        }
SWIGINTERN bool std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__iterator_isNot(std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator const *self,std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator other){
          return (*self != other);
        }
SWIGINTERN std::string std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__iterator_getKey(std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator const *self){
          return (*self)->first;
        }
SWIGINTERN std::shared_ptr< sigrok::Option > std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__iterator_getValue(std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator const *self){
          return (*self)->second;
        }
SWIGINTERN void std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__iterator_setValue(std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator *self,std::shared_ptr< sigrok::Option > const &newValue){
          (*self)->second = newValue;
        }
SWIGINTERN jint std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__sizeImpl(std::map< std::string,std::shared_ptr< sigrok::Option > > const *self){
        return SWIG_MapSize(self->size());
      }
SWIGINTERN bool std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__containsImpl(std::map< std::string,std::shared_ptr< sigrok::Option > > *self,std::string const &key){
        return (self->count(key) > 0);
      }
SWIGINTERN void std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__putUnchecked(std::map< std::string,std::shared_ptr< sigrok::Option > > *self,std::string const &key,std::shared_ptr< sigrok::Option > const &value){
#ifdef __cpp_lib_map_try_emplace
        (*self).insert_or_assign(key, value);
#else
        (*self)[key] = value;
#endif
      }
SWIGINTERN void std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__removeUnchecked(std::map< std::string,std::shared_ptr< sigrok::Option > > *self,std::map< std::string,std::shared_ptr< sigrok::Option >,std::less< std::string > >::iterator const itr){
        self->erase(itr);
      }
SWIGINTERN std::vector< Glib::VariantBase > *new_std_vector_Sl_Glib_VariantBase_Sg___SWIG_2(jint count,Glib::VariantBase const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< Glib::VariantBase >(static_cast<std::vector< Glib::VariantBase >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_Glib_VariantBase_Sg__doCapacity(std::vector< Glib::VariantBase > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_Glib_VariantBase_Sg__doReserve(std::vector< Glib::VariantBase > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_Glib_VariantBase_Sg__doSize(std::vector< Glib::VariantBase > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_Glib_VariantBase_Sg__doAdd__SWIG_0(std::vector< Glib::VariantBase > *self,std::vector< Glib::VariantBase >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_Glib_VariantBase_Sg__doAdd__SWIG_1(std::vector< Glib::VariantBase > *self,jint index,std::vector< Glib::VariantBase >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< Glib::VariantBase >::value_type std_vector_Sl_Glib_VariantBase_Sg__doRemove(std::vector< Glib::VariantBase > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          Glib::VariantBase const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< Glib::VariantBase >::value_type const &std_vector_Sl_Glib_VariantBase_Sg__doGet(std::vector< Glib::VariantBase > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< Glib::VariantBase >::value_type std_vector_Sl_Glib_VariantBase_Sg__doSet(std::vector< Glib::VariantBase > *self,jint index,std::vector< Glib::VariantBase >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          Glib::VariantBase const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_Glib_VariantBase_Sg__doRemoveRange(std::vector< Glib::VariantBase > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::map< std::string,Glib::VariantBase,std::less< std::string > >::iterator std_map_Sl_std_string_Sc_Glib_VariantBase_Sg__iterator_getNextUnchecked(std::map< std::string,Glib::VariantBase >::iterator *self){
          std::map< std::string, Glib::VariantBase, std::less< std::string > >::iterator copy = (*self);
          return ++copy;
        }
SWIGINTERN bool std_map_Sl_std_string_Sc_Glib_VariantBase_Sg__iterator_isNot(std::map< std::string,Glib::VariantBase >::iterator const *self,std::map< std::string,Glib::VariantBase >::iterator other){
          return (*self != other);
        }
SWIGINTERN std::string std_map_Sl_std_string_Sc_Glib_VariantBase_Sg__iterator_getKey(std::map< std::string,Glib::VariantBase >::iterator const *self){
          return (*self)->first;
        }
SWIGINTERN Glib::VariantBase std_map_Sl_std_string_Sc_Glib_VariantBase_Sg__iterator_getValue(std::map< std::string,Glib::VariantBase >::iterator const *self){
          return (*self)->second;
        }
SWIGINTERN void std_map_Sl_std_string_Sc_Glib_VariantBase_Sg__iterator_setValue(std::map< std::string,Glib::VariantBase >::iterator *self,Glib::VariantBase const &newValue){
          (*self)->second = newValue;
        }
SWIGINTERN jint std_map_Sl_std_string_Sc_Glib_VariantBase_Sg__sizeImpl(std::map< std::string,Glib::VariantBase > const *self){
        return SWIG_MapSize(self->size());
      }
SWIGINTERN bool std_map_Sl_std_string_Sc_Glib_VariantBase_Sg__containsImpl(std::map< std::string,Glib::VariantBase > *self,std::string const &key){
        return (self->count(key) > 0);
      }
SWIGINTERN void std_map_Sl_std_string_Sc_Glib_VariantBase_Sg__putUnchecked(std::map< std::string,Glib::VariantBase > *self,std::string const &key,Glib::VariantBase const &value){
#ifdef __cpp_lib_map_try_emplace
        (*self).insert_or_assign(key, value);
#else
        (*self)[key] = value;
#endif
      }
SWIGINTERN void std_map_Sl_std_string_Sc_Glib_VariantBase_Sg__removeUnchecked(std::map< std::string,Glib::VariantBase > *self,std::map< std::string,Glib::VariantBase,std::less< std::string > >::iterator const itr){
        self->erase(itr);
      }
SWIGINTERN std::vector< sigrok::QuantityFlag const * > *new_std_vector_Sl_sigrok_QuantityFlag_SS_const_Sm__Sg___SWIG_2(jint count,sigrok::QuantityFlag const *const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< sigrok::QuantityFlag const * >(static_cast<std::vector< sigrok::QuantityFlag const * >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_sigrok_QuantityFlag_SS_const_Sm__Sg__doCapacity(std::vector< sigrok::QuantityFlag const * > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_sigrok_QuantityFlag_SS_const_Sm__Sg__doReserve(std::vector< sigrok::QuantityFlag const * > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_sigrok_QuantityFlag_SS_const_Sm__Sg__doSize(std::vector< sigrok::QuantityFlag const * > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_sigrok_QuantityFlag_SS_const_Sm__Sg__doAdd__SWIG_0(std::vector< sigrok::QuantityFlag const * > *self,std::vector< sigrok::QuantityFlag const * >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_sigrok_QuantityFlag_SS_const_Sm__Sg__doAdd__SWIG_1(std::vector< sigrok::QuantityFlag const * > *self,jint index,std::vector< sigrok::QuantityFlag const * >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< sigrok::QuantityFlag const * >::value_type std_vector_Sl_sigrok_QuantityFlag_SS_const_Sm__Sg__doRemove(std::vector< sigrok::QuantityFlag const * > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          sigrok::QuantityFlag const * const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< sigrok::QuantityFlag const * >::value_type const &std_vector_Sl_sigrok_QuantityFlag_SS_const_Sm__Sg__doGet(std::vector< sigrok::QuantityFlag const * > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< sigrok::QuantityFlag const * >::value_type std_vector_Sl_sigrok_QuantityFlag_SS_const_Sm__Sg__doSet(std::vector< sigrok::QuantityFlag const * > *self,jint index,std::vector< sigrok::QuantityFlag const * >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          sigrok::QuantityFlag const * const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_sigrok_QuantityFlag_SS_const_Sm__Sg__doRemoveRange(std::vector< sigrok::QuantityFlag const * > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::shared_ptr< sigrok::TriggerStage > > *new_std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerStage_Sg__Sg___SWIG_2(jint count,std::shared_ptr< sigrok::TriggerStage > const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< std::shared_ptr< sigrok::TriggerStage > >(static_cast<std::vector< std::shared_ptr< sigrok::TriggerStage > >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerStage_Sg__Sg__doCapacity(std::vector< std::shared_ptr< sigrok::TriggerStage > > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerStage_Sg__Sg__doReserve(std::vector< std::shared_ptr< sigrok::TriggerStage > > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerStage_Sg__Sg__doSize(std::vector< std::shared_ptr< sigrok::TriggerStage > > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerStage_Sg__Sg__doAdd__SWIG_0(std::vector< std::shared_ptr< sigrok::TriggerStage > > *self,std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerStage_Sg__Sg__doAdd__SWIG_1(std::vector< std::shared_ptr< sigrok::TriggerStage > > *self,jint index,std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerStage_Sg__Sg__doRemove(std::vector< std::shared_ptr< sigrok::TriggerStage > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          std::shared_ptr< sigrok::TriggerStage > const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type const &std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerStage_Sg__Sg__doGet(std::vector< std::shared_ptr< sigrok::TriggerStage > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerStage_Sg__Sg__doSet(std::vector< std::shared_ptr< sigrok::TriggerStage > > *self,jint index,std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          std::shared_ptr< sigrok::TriggerStage > const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerStage_Sg__Sg__doRemoveRange(std::vector< std::shared_ptr< sigrok::TriggerStage > > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::shared_ptr< sigrok::TriggerMatch > > *new_std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerMatch_Sg__Sg___SWIG_2(jint count,std::shared_ptr< sigrok::TriggerMatch > const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< std::shared_ptr< sigrok::TriggerMatch > >(static_cast<std::vector< std::shared_ptr< sigrok::TriggerMatch > >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerMatch_Sg__Sg__doCapacity(std::vector< std::shared_ptr< sigrok::TriggerMatch > > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerMatch_Sg__Sg__doReserve(std::vector< std::shared_ptr< sigrok::TriggerMatch > > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerMatch_Sg__Sg__doSize(std::vector< std::shared_ptr< sigrok::TriggerMatch > > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerMatch_Sg__Sg__doAdd__SWIG_0(std::vector< std::shared_ptr< sigrok::TriggerMatch > > *self,std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerMatch_Sg__Sg__doAdd__SWIG_1(std::vector< std::shared_ptr< sigrok::TriggerMatch > > *self,jint index,std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerMatch_Sg__Sg__doRemove(std::vector< std::shared_ptr< sigrok::TriggerMatch > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          std::shared_ptr< sigrok::TriggerMatch > const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type const &std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerMatch_Sg__Sg__doGet(std::vector< std::shared_ptr< sigrok::TriggerMatch > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerMatch_Sg__Sg__doSet(std::vector< std::shared_ptr< sigrok::TriggerMatch > > *self,jint index,std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          std::shared_ptr< sigrok::TriggerMatch > const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerMatch_Sg__Sg__doRemoveRange(std::vector< std::shared_ptr< sigrok::TriggerMatch > > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }

namespace {
  class ScopedEnv {
    public:
      ScopedEnv(JavaVM *jvm);
      ~ScopedEnv();
      JNIEnv* operator-> () { return env; }
      operator bool () const { return (bool)env; }
    protected:
      JavaVM *jvm;
      JNIEnv *env;
      int env_status;
  };
  ScopedEnv::ScopedEnv(JavaVM *jvm) : jvm(jvm), env(NULL) {
    env_status = jvm->GetEnv((void **)&env, JNI_VERSION_1_2);
    if (env_status == JNI_EDETACHED) {
#if defined(__ANDROID__)
      jvm->AttachCurrentThread(&env, NULL);
#else
      jvm->AttachCurrentThread((void **)&env, NULL);
#endif
    }
  }
  ScopedEnv::~ScopedEnv() {
    if (env_status == JNI_EDETACHED) {
      jvm->DetachCurrentThread();
    }
  }
}


namespace {
  class GlobalRefBase
  {
    protected:
      GlobalRefBase (JavaVM *jvm, jobject ref);
      ~GlobalRefBase ();
      JavaVM *jvm;
      jobject jref;
  };
  GlobalRefBase::GlobalRefBase (JavaVM *jvm, jobject ref) : jvm(jvm), jref(0) {
    ScopedEnv env(jvm);
    if (env && ref)
      jref = env->NewGlobalRef(ref);
  }
  GlobalRefBase::~GlobalRefBase () {
    ScopedEnv env(jvm);
    if(env && jref)
      env->DeleteGlobalRef(jref);
  }
  template <class Jtype>
  class GlobalRef : protected GlobalRefBase
  {
    public:
      GlobalRef (JavaVM *jvm, Jtype ref) : GlobalRefBase(jvm, ref) {}
      GlobalRef (const GlobalRef &ref) : GlobalRefBase(ref.jvm, ref.jref) {}
      operator Jtype () const { return static_cast<Jtype>(jref); }
  };
}


typedef jobject jlogcallback;


typedef jobject jdatafeedcallback;


SWIGINTERN void SWIG_JavaException(JNIEnv *jenv, int code, const char *msg) {
  SWIG_JavaExceptionCodes exception_code = SWIG_JavaUnknownError;
  switch(code) {
  case SWIG_MemoryError:
    exception_code = SWIG_JavaOutOfMemoryError;
    break;
  case SWIG_IOError:
    exception_code = SWIG_JavaIOException;
    break;
  case SWIG_SystemError:
  case SWIG_RuntimeError:
    exception_code = SWIG_JavaRuntimeException;
    break;
  case SWIG_OverflowError:
  case SWIG_IndexError:
    exception_code = SWIG_JavaIndexOutOfBoundsException;
    break;
  case SWIG_DivisionByZero:
    exception_code = SWIG_JavaArithmeticException;
    break;
  case SWIG_SyntaxError:
  case SWIG_ValueError:
  case SWIG_TypeError:
    exception_code = SWIG_JavaIllegalArgumentException;
    break;
  case SWIG_NullReferenceError:
    exception_code = SWIG_JavaNullPointerException;
    break;
  case SWIG_UnknownError:
  default:
    exception_code = SWIG_JavaUnknownError;
    break;
  }
  SWIG_JavaThrowException(jenv, exception_code, msg);
}


#include <typeinfo>
#include <stdexcept>



static int swig_exception_code(int sigrok_exception_code) {
    switch (sigrok_exception_code) {
        case SR_ERR_MALLOC:
            return SWIG_MemoryError;
        case SR_ERR_ARG:
            return SWIG_ValueError;
        default:
            return SWIG_RuntimeError;
    }
}


SWIGINTERN void sigrok_Context_add_log_callback(sigrok::Context *self,JNIEnv *env,jlogcallback obj){
    JavaVM *jvm = NULL;
    env->GetJavaVM(&jvm);
    jclass obj_class = env->GetObjectClass(obj);
    jmethodID method = env->GetMethodID(obj_class, "run",
      "(Lorg/sigrok/core/classes/LogLevel;Ljava/lang/String;)V");
    GlobalRef<jclass> LogLevel(jvm, env->FindClass("org/sigrok/core/classes/LogLevel"));
    jmethodID LogLevel_init = env->GetMethodID(LogLevel, "<init>", "(JZ)V");
    GlobalRef<jobject> obj_ref(jvm, obj);

    self->set_log_callback([=] (
      const sigrok::LogLevel *loglevel,
      std::string message)
    {
      ScopedEnv env(jvm);
      if (!env)
        throw sigrok::Error(SR_ERR);
      jlong loglevel_addr = 0;
      *(const sigrok::LogLevel **) &loglevel_addr = loglevel;
      jobject loglevel_obj = env->NewObject(
        LogLevel, LogLevel_init, loglevel_addr, false);
      jobject message_obj = env->NewStringUTF(message.c_str());
      env->CallVoidMethod(obj_ref, method, loglevel_obj, message_obj);
      if (env->ExceptionCheck())
        throw sigrok::Error(SR_ERR);
    });
  }
SWIGINTERN void sigrok_Session_add_datafeed_callback__SWIG_1(sigrok::Session *self,JNIEnv *env,jdatafeedcallback obj){
    JavaVM *jvm = NULL;
    env->GetJavaVM(&jvm);
    jclass obj_class = env->GetObjectClass(obj);
    jmethodID method = env->GetMethodID(obj_class, "run",
      "(Lorg/sigrok/core/classes/Device;Lorg/sigrok/core/classes/Packet;)V");
    GlobalRef<jclass> Device(jvm, env->FindClass("org/sigrok/core/classes/Device"));
    jmethodID Device_init = env->GetMethodID(Device, "<init>", "(JZ)V");
    GlobalRef<jclass> Packet(jvm, env->FindClass("org/sigrok/core/classes/Packet"));
    jmethodID Packet_init = env->GetMethodID(Packet, "<init>", "(JZ)V");
    GlobalRef<jobject> obj_ref(jvm, obj);

    self->add_datafeed_callback([=] (
      std::shared_ptr<sigrok::Device> device,
      std::shared_ptr<sigrok::Packet> packet)
    {
      ScopedEnv env(jvm);
      if (!env)
        throw sigrok::Error(SR_ERR);
      jlong device_addr = 0;
      jlong packet_addr = 0;
      *(std::shared_ptr<sigrok::Device> **) &device_addr =
        new std::shared_ptr<sigrok::Device>(device);
      *(std::shared_ptr<sigrok::Packet> **) &packet_addr =
        new std::shared_ptr<sigrok::Packet>(packet);
      jobject device_obj = env->NewObject(
        Device, Device_init, device_addr, true);
      jobject packet_obj = env->NewObject(
        Packet, Packet_init, packet_addr, true);
      env->CallVoidMethod(obj_ref, method, device_obj, packet_obj);
      if (env->ExceptionCheck())
        throw sigrok::Error(SR_ERR);
    });
  }

#ifdef __cplusplus
extern "C" {
#endif

SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1Variant(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  Glib::VariantBase *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (Glib::VariantBase *)new Glib::VariantBase();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(Glib::VariantBase **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1Variant(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  Glib::VariantBase *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(Glib::VariantBase **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1StringMap_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::map< std::string,std::string > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (std::map< std::string,std::string > *)new std::map< std::string,std::string >();
  *(std::map< std::string,std::string > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1StringMap_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::string > *arg1 = 0 ;
  std::map< std::string,std::string > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::map< std::string,std::string > const & is null");
    return 0;
  } 
  result = (std::map< std::string,std::string > *)new std::map< std::string,std::string >((std::map< std::string,std::string > const &)*arg1);
  *(std::map< std::string,std::string > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_StringMap_1Iterator_1getNextUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::string >::iterator *arg1 = 0 ;
  std::map< std::string,std::string,std::less< std::string > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string >::iterator **)&jarg1; 
  result = std_map_Sl_std_string_Sc_std_string_Sg__iterator_getNextUnchecked(arg1);
  *(std::map< std::string,std::string,std::less< std::string > >::iterator **)&jresult = new std::map< std::string,std::string,std::less< std::string > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_StringMap_1Iterator_1isNot(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  std::map< std::string,std::string >::iterator *arg1 = 0 ;
  std::map< std::string,std::string >::iterator arg2 ;
  std::map< std::string,std::string >::iterator *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< std::string,std::string >::iterator **)&jarg1; 
  argp2 = *(std::map< std::string,std::string >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,std::string >::iterator");
    return 0;
  }
  arg2 = *argp2; 
  result = (bool)std_map_Sl_std_string_Sc_std_string_Sg__iterator_isNot((std::map< std::string,std::string >::iterator const *)arg1,SWIG_STD_MOVE(arg2));
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_StringMap_1Iterator_1getKey(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  std::map< std::string,std::string >::iterator *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string >::iterator **)&jarg1; 
  result = std_map_Sl_std_string_Sc_std_string_Sg__iterator_getKey((std::map< std::string,std::string >::iterator const *)arg1);
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_StringMap_1Iterator_1getValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  std::map< std::string,std::string >::iterator *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string >::iterator **)&jarg1; 
  result = std_map_Sl_std_string_Sc_std_string_Sg__iterator_getValue((std::map< std::string,std::string >::iterator const *)arg1);
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_StringMap_1Iterator_1setValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  std::map< std::string,std::string >::iterator *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string >::iterator **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  std_map_Sl_std_string_Sc_std_string_Sg__iterator_setValue(arg1,(std::string const &)*arg2);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1StringMap_1Iterator(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< std::string,std::string >::iterator *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< std::string,std::string >::iterator **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_StringMap_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::map< std::string,std::string > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string > **)&jarg1; 
  result = (bool)((std::map< std::string,std::string > const *)arg1)->empty();
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_StringMap_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::map< std::string,std::string > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string > **)&jarg1; 
  (arg1)->clear();
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_StringMap_1find(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  std::map< std::string,std::string > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::map< std::string,std::string >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  result = (arg1)->find((std::string const &)*arg2);
  *(std::map< std::string,std::string >::iterator **)&jresult = new std::map< std::string,std::string >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_StringMap_1begin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::string > *arg1 = 0 ;
  std::map< std::string,std::string >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string > **)&jarg1; 
  result = (arg1)->begin();
  *(std::map< std::string,std::string >::iterator **)&jresult = new std::map< std::string,std::string >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_StringMap_1end(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::string > *arg1 = 0 ;
  std::map< std::string,std::string >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string > **)&jarg1; 
  result = (arg1)->end();
  *(std::map< std::string,std::string >::iterator **)&jresult = new std::map< std::string,std::string >::iterator(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_StringMap_1sizeImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::map< std::string,std::string > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string > **)&jarg1; 
  try {
    result = std_map_Sl_std_string_Sc_std_string_Sg__sizeImpl((std::map< std::string,std::string > const *)arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_StringMap_1containsImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jboolean jresult = 0 ;
  std::map< std::string,std::string > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  result = (bool)std_map_Sl_std_string_Sc_std_string_Sg__containsImpl(arg1,(std::string const &)*arg2);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_StringMap_1putUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
  std::map< std::string,std::string > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return ;
  std::string arg3_str(arg3_pstr);
  arg3 = &arg3_str;
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  std_map_Sl_std_string_Sc_std_string_Sg__putUnchecked(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_StringMap_1removeUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::map< std::string,std::string > *arg1 = 0 ;
  std::map< std::string,std::string,std::less< std::string > >::iterator arg2 ;
  std::map< std::string,std::string,std::less< std::string > >::iterator const *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< std::string,std::string > **)&jarg1; 
  argp2 = *(std::map< std::string,std::string,std::less< std::string > >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,std::string,std::less< std::string > >::iterator const");
    return ;
  }
  arg2 = *argp2; 
  std_map_Sl_std_string_Sc_std_string_Sg__removeUnchecked(arg1,SWIG_STD_MOVE(arg2));
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1StringMap(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< std::string,std::string > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< std::string,std::string > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1DriverMap_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Driver > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (std::map< std::string,std::shared_ptr< sigrok::Driver > > *)new std::map< std::string,std::shared_ptr< sigrok::Driver > >();
  *(std::map< std::string,std::shared_ptr< sigrok::Driver > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1DriverMap_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Driver > > *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Driver > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Driver > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::map< std::string,std::shared_ptr< sigrok::Driver > > const & is null");
    return 0;
  } 
  result = (std::map< std::string,std::shared_ptr< sigrok::Driver > > *)new std::map< std::string,std::shared_ptr< sigrok::Driver > >((std::map< std::string,std::shared_ptr< sigrok::Driver > > const &)*arg1);
  *(std::map< std::string,std::shared_ptr< sigrok::Driver > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_DriverMap_1Iterator_1getNextUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Driver >,std::less< std::string > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator **)&jarg1; 
  result = std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Driver_Sg__Sg__iterator_getNextUnchecked(arg1);
  *(std::map< std::string,std::shared_ptr< sigrok::Driver >,std::less< std::string > >::iterator **)&jresult = new std::map< std::string,std::shared_ptr< sigrok::Driver >,std::less< std::string > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_DriverMap_1Iterator_1isNot(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator arg2 ;
  std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator **)&jarg1; 
  argp2 = *(std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator");
    return 0;
  }
  arg2 = *argp2; 
  result = (bool)std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Driver_Sg__Sg__iterator_isNot((std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator const *)arg1,SWIG_STD_MOVE(arg2));
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_DriverMap_1Iterator_1getKey(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator **)&jarg1; 
  result = std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Driver_Sg__Sg__iterator_getKey((std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator const *)arg1);
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_DriverMap_1Iterator_1getValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator *arg1 = 0 ;
  std::shared_ptr< sigrok::Driver > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator **)&jarg1; 
  result = std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Driver_Sg__Sg__iterator_getValue((std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator const *)arg1);
  *(std::shared_ptr< sigrok::Driver > **)&jresult = new std::shared_ptr< sigrok::Driver >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_DriverMap_1Iterator_1setValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator *arg1 = 0 ;
  std::shared_ptr< sigrok::Driver > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator **)&jarg1; 
  arg2 = *(std::shared_ptr< sigrok::Driver > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::shared_ptr< sigrok::Driver > const & is null");
    return ;
  } 
  std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Driver_Sg__Sg__iterator_setValue(arg1,(std::shared_ptr< sigrok::Driver > const &)*arg2);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1DriverMap_1Iterator(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_DriverMap_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Driver > > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Driver > > **)&jarg1; 
  result = (bool)((std::map< std::string,std::shared_ptr< sigrok::Driver > > const *)arg1)->empty();
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_DriverMap_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::map< std::string,std::shared_ptr< sigrok::Driver > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Driver > > **)&jarg1; 
  (arg1)->clear();
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_DriverMap_1find(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Driver > > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Driver > > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  result = (arg1)->find((std::string const &)*arg2);
  *(std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator **)&jresult = new std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_DriverMap_1begin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Driver > > *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Driver > > **)&jarg1; 
  result = (arg1)->begin();
  *(std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator **)&jresult = new std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_DriverMap_1end(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Driver > > *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Driver > > **)&jarg1; 
  result = (arg1)->end();
  *(std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator **)&jresult = new std::map< std::string,std::shared_ptr< sigrok::Driver > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_DriverMap_1sizeImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Driver > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Driver > > **)&jarg1; 
  try {
    result = std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Driver_Sg__Sg__sizeImpl((std::map< std::string,std::shared_ptr< sigrok::Driver > > const *)arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_DriverMap_1containsImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jboolean jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Driver > > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Driver > > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  result = (bool)std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Driver_Sg__Sg__containsImpl(arg1,(std::string const &)*arg2);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_DriverMap_1putUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3) {
  std::map< std::string,std::shared_ptr< sigrok::Driver > > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::shared_ptr< sigrok::Driver > *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Driver > > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = *(std::shared_ptr< sigrok::Driver > **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::shared_ptr< sigrok::Driver > const & is null");
    return ;
  } 
  std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Driver_Sg__Sg__putUnchecked(arg1,(std::string const &)*arg2,(std::shared_ptr< sigrok::Driver > const &)*arg3);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_DriverMap_1removeUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::map< std::string,std::shared_ptr< sigrok::Driver > > *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Driver >,std::less< std::string > >::iterator arg2 ;
  std::map< std::string,std::shared_ptr< sigrok::Driver >,std::less< std::string > >::iterator const *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Driver > > **)&jarg1; 
  argp2 = *(std::map< std::string,std::shared_ptr< sigrok::Driver >,std::less< std::string > >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,std::shared_ptr< sigrok::Driver >,std::less< std::string > >::iterator const");
    return ;
  }
  arg2 = *argp2; 
  std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Driver_Sg__Sg__removeUnchecked(arg1,SWIG_STD_MOVE(arg2));
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1DriverMap(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< std::string,std::shared_ptr< sigrok::Driver > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Driver > > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1InputFormatMap_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (std::map< std::string,std::shared_ptr< sigrok::InputFormat > > *)new std::map< std::string,std::shared_ptr< sigrok::InputFormat > >();
  *(std::map< std::string,std::shared_ptr< sigrok::InputFormat > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1InputFormatMap_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > > *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::InputFormat > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::map< std::string,std::shared_ptr< sigrok::InputFormat > > const & is null");
    return 0;
  } 
  result = (std::map< std::string,std::shared_ptr< sigrok::InputFormat > > *)new std::map< std::string,std::shared_ptr< sigrok::InputFormat > >((std::map< std::string,std::shared_ptr< sigrok::InputFormat > > const &)*arg1);
  *(std::map< std::string,std::shared_ptr< sigrok::InputFormat > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_InputFormatMap_1Iterator_1getNextUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::InputFormat >,std::less< std::string > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator **)&jarg1; 
  result = std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_InputFormat_Sg__Sg__iterator_getNextUnchecked(arg1);
  *(std::map< std::string,std::shared_ptr< sigrok::InputFormat >,std::less< std::string > >::iterator **)&jresult = new std::map< std::string,std::shared_ptr< sigrok::InputFormat >,std::less< std::string > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_InputFormatMap_1Iterator_1isNot(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator arg2 ;
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator **)&jarg1; 
  argp2 = *(std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator");
    return 0;
  }
  arg2 = *argp2; 
  result = (bool)std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_InputFormat_Sg__Sg__iterator_isNot((std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator const *)arg1,SWIG_STD_MOVE(arg2));
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_InputFormatMap_1Iterator_1getKey(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator **)&jarg1; 
  result = std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_InputFormat_Sg__Sg__iterator_getKey((std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator const *)arg1);
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_InputFormatMap_1Iterator_1getValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator *arg1 = 0 ;
  std::shared_ptr< sigrok::InputFormat > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator **)&jarg1; 
  result = std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_InputFormat_Sg__Sg__iterator_getValue((std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator const *)arg1);
  *(std::shared_ptr< sigrok::InputFormat > **)&jresult = new std::shared_ptr< sigrok::InputFormat >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_InputFormatMap_1Iterator_1setValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator *arg1 = 0 ;
  std::shared_ptr< sigrok::InputFormat > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator **)&jarg1; 
  arg2 = *(std::shared_ptr< sigrok::InputFormat > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::shared_ptr< sigrok::InputFormat > const & is null");
    return ;
  } 
  std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_InputFormat_Sg__Sg__iterator_setValue(arg1,(std::shared_ptr< sigrok::InputFormat > const &)*arg2);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1InputFormatMap_1Iterator(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_InputFormatMap_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::InputFormat > > **)&jarg1; 
  result = (bool)((std::map< std::string,std::shared_ptr< sigrok::InputFormat > > const *)arg1)->empty();
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_InputFormatMap_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::InputFormat > > **)&jarg1; 
  (arg1)->clear();
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_InputFormatMap_1find(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::InputFormat > > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  result = (arg1)->find((std::string const &)*arg2);
  *(std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator **)&jresult = new std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_InputFormatMap_1begin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > > *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::InputFormat > > **)&jarg1; 
  result = (arg1)->begin();
  *(std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator **)&jresult = new std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_InputFormatMap_1end(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > > *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::InputFormat > > **)&jarg1; 
  result = (arg1)->end();
  *(std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator **)&jresult = new std::map< std::string,std::shared_ptr< sigrok::InputFormat > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_InputFormatMap_1sizeImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::InputFormat > > **)&jarg1; 
  try {
    result = std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_InputFormat_Sg__Sg__sizeImpl((std::map< std::string,std::shared_ptr< sigrok::InputFormat > > const *)arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_InputFormatMap_1containsImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jboolean jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::InputFormat > > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  result = (bool)std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_InputFormat_Sg__Sg__containsImpl(arg1,(std::string const &)*arg2);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_InputFormatMap_1putUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3) {
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::shared_ptr< sigrok::InputFormat > *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::InputFormat > > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = *(std::shared_ptr< sigrok::InputFormat > **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::shared_ptr< sigrok::InputFormat > const & is null");
    return ;
  } 
  std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_InputFormat_Sg__Sg__putUnchecked(arg1,(std::string const &)*arg2,(std::shared_ptr< sigrok::InputFormat > const &)*arg3);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_InputFormatMap_1removeUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > > *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::InputFormat >,std::less< std::string > >::iterator arg2 ;
  std::map< std::string,std::shared_ptr< sigrok::InputFormat >,std::less< std::string > >::iterator const *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::InputFormat > > **)&jarg1; 
  argp2 = *(std::map< std::string,std::shared_ptr< sigrok::InputFormat >,std::less< std::string > >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,std::shared_ptr< sigrok::InputFormat >,std::less< std::string > >::iterator const");
    return ;
  }
  arg2 = *argp2; 
  std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_InputFormat_Sg__Sg__removeUnchecked(arg1,SWIG_STD_MOVE(arg2));
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1InputFormatMap(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< std::string,std::shared_ptr< sigrok::InputFormat > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::InputFormat > > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1OutputFormatMap_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > *)new std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >();
  *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1OutputFormatMap_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > const & is null");
    return 0;
  } 
  result = (std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > *)new std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >((std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > const &)*arg1);
  *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFormatMap_1Iterator_1getNextUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat >,std::less< std::string > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator **)&jarg1; 
  result = std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_OutputFormat_Sg__Sg__iterator_getNextUnchecked(arg1);
  *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat >,std::less< std::string > >::iterator **)&jresult = new std::map< std::string,std::shared_ptr< sigrok::OutputFormat >,std::less< std::string > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFormatMap_1Iterator_1isNot(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator arg2 ;
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator **)&jarg1; 
  argp2 = *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator");
    return 0;
  }
  arg2 = *argp2; 
  result = (bool)std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_OutputFormat_Sg__Sg__iterator_isNot((std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator const *)arg1,SWIG_STD_MOVE(arg2));
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFormatMap_1Iterator_1getKey(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator **)&jarg1; 
  result = std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_OutputFormat_Sg__Sg__iterator_getKey((std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator const *)arg1);
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFormatMap_1Iterator_1getValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator *arg1 = 0 ;
  std::shared_ptr< sigrok::OutputFormat > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator **)&jarg1; 
  result = std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_OutputFormat_Sg__Sg__iterator_getValue((std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator const *)arg1);
  *(std::shared_ptr< sigrok::OutputFormat > **)&jresult = new std::shared_ptr< sigrok::OutputFormat >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFormatMap_1Iterator_1setValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator *arg1 = 0 ;
  std::shared_ptr< sigrok::OutputFormat > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator **)&jarg1; 
  arg2 = *(std::shared_ptr< sigrok::OutputFormat > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::shared_ptr< sigrok::OutputFormat > const & is null");
    return ;
  } 
  std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_OutputFormat_Sg__Sg__iterator_setValue(arg1,(std::shared_ptr< sigrok::OutputFormat > const &)*arg2);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1OutputFormatMap_1Iterator(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFormatMap_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > **)&jarg1; 
  result = (bool)((std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > const *)arg1)->empty();
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFormatMap_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > **)&jarg1; 
  (arg1)->clear();
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFormatMap_1find(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  result = (arg1)->find((std::string const &)*arg2);
  *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator **)&jresult = new std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFormatMap_1begin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > **)&jarg1; 
  result = (arg1)->begin();
  *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator **)&jresult = new std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFormatMap_1end(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > **)&jarg1; 
  result = (arg1)->end();
  *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator **)&jresult = new std::map< std::string,std::shared_ptr< sigrok::OutputFormat > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFormatMap_1sizeImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > **)&jarg1; 
  try {
    result = std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_OutputFormat_Sg__Sg__sizeImpl((std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > const *)arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFormatMap_1containsImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jboolean jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  result = (bool)std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_OutputFormat_Sg__Sg__containsImpl(arg1,(std::string const &)*arg2);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFormatMap_1putUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3) {
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::shared_ptr< sigrok::OutputFormat > *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = *(std::shared_ptr< sigrok::OutputFormat > **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::shared_ptr< sigrok::OutputFormat > const & is null");
    return ;
  } 
  std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_OutputFormat_Sg__Sg__putUnchecked(arg1,(std::string const &)*arg2,(std::shared_ptr< sigrok::OutputFormat > const &)*arg3);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFormatMap_1removeUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat >,std::less< std::string > >::iterator arg2 ;
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat >,std::less< std::string > >::iterator const *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > **)&jarg1; 
  argp2 = *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat >,std::less< std::string > >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,std::shared_ptr< sigrok::OutputFormat >,std::less< std::string > >::iterator const");
    return ;
  }
  arg2 = *argp2; 
  std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_OutputFormat_Sg__Sg__removeUnchecked(arg1,SWIG_STD_MOVE(arg2));
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1OutputFormatMap(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::OutputFormat > > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1HardwareDeviceVector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::HardwareDevice > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (std::vector< std::shared_ptr< sigrok::HardwareDevice > > *)new std::vector< std::shared_ptr< sigrok::HardwareDevice > >();
  *(std::vector< std::shared_ptr< sigrok::HardwareDevice > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1HardwareDeviceVector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::HardwareDevice > > *arg1 = 0 ;
  std::vector< std::shared_ptr< sigrok::HardwareDevice > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::HardwareDevice > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::HardwareDevice > > const & is null");
    return 0;
  } 
  result = (std::vector< std::shared_ptr< sigrok::HardwareDevice > > *)new std::vector< std::shared_ptr< sigrok::HardwareDevice > >((std::vector< std::shared_ptr< sigrok::HardwareDevice > > const &)*arg1);
  *(std::vector< std::shared_ptr< sigrok::HardwareDevice > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_HardwareDeviceVector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::HardwareDevice > > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::HardwareDevice > > **)&jarg1; 
  result = (bool)((std::vector< std::shared_ptr< sigrok::HardwareDevice > > const *)arg1)->empty();
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_HardwareDeviceVector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< std::shared_ptr< sigrok::HardwareDevice > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::HardwareDevice > > **)&jarg1; 
  (arg1)->clear();
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1HardwareDeviceVector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2) {
  jlong jresult = 0 ;
  jint arg1 ;
  std::shared_ptr< sigrok::HardwareDevice > *arg2 = 0 ;
  std::vector< std::shared_ptr< sigrok::HardwareDevice > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = jarg1; 
  arg2 = *(std::shared_ptr< sigrok::HardwareDevice > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::shared_ptr< sigrok::HardwareDevice > const & is null");
    return 0;
  } 
  try {
    result = (std::vector< std::shared_ptr< sigrok::HardwareDevice > > *)new_std_vector_Sl_std_shared_ptr_Sl_sigrok_HardwareDevice_Sg__Sg___SWIG_2(SWIG_STD_MOVE(arg1),(std::shared_ptr< sigrok::HardwareDevice > const &)*arg2);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::HardwareDevice > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_HardwareDeviceVector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::HardwareDevice > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::HardwareDevice > > **)&jarg1; 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_HardwareDevice_Sg__Sg__doCapacity(arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_HardwareDeviceVector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< std::shared_ptr< sigrok::HardwareDevice > > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::HardwareDevice > > **)&jarg1; 
  arg2 = jarg2; 
  try {
    std_vector_Sl_std_shared_ptr_Sl_sigrok_HardwareDevice_Sg__Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::length_error &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_HardwareDeviceVector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::HardwareDevice > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::HardwareDevice > > **)&jarg1; 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_HardwareDevice_Sg__Sg__doSize((std::vector< std::shared_ptr< sigrok::HardwareDevice > > const *)arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_HardwareDeviceVector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< std::shared_ptr< sigrok::HardwareDevice > > *arg1 = 0 ;
  std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::HardwareDevice > > **)&jarg1; 
  arg2 = *(std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type const & is null");
    return ;
  } 
  std_vector_Sl_std_shared_ptr_Sl_sigrok_HardwareDevice_Sg__Sg__doAdd__SWIG_0(arg1,(std::shared_ptr< sigrok::HardwareDevice > const &)*arg2);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_HardwareDeviceVector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  std::vector< std::shared_ptr< sigrok::HardwareDevice > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::HardwareDevice > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type const & is null");
    return ;
  } 
  try {
    std_vector_Sl_std_shared_ptr_Sl_sigrok_HardwareDevice_Sg__Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(std::shared_ptr< sigrok::HardwareDevice > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_HardwareDeviceVector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::HardwareDevice > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::HardwareDevice > > **)&jarg1; 
  arg2 = jarg2; 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_HardwareDevice_Sg__Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type **)&jresult = new std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_HardwareDeviceVector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::HardwareDevice > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::HardwareDevice > > **)&jarg1; 
  arg2 = jarg2; 
  try {
    result = (std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type *) &std_vector_Sl_std_shared_ptr_Sl_sigrok_HardwareDevice_Sg__Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_HardwareDeviceVector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::HardwareDevice > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type *arg3 = 0 ;
  std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::HardwareDevice > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type const & is null");
    return 0;
  } 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_HardwareDevice_Sg__Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(std::shared_ptr< sigrok::HardwareDevice > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type **)&jresult = new std::vector< std::shared_ptr< sigrok::HardwareDevice > >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_HardwareDeviceVector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< std::shared_ptr< sigrok::HardwareDevice > > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::HardwareDevice > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  try {
    std_vector_Sl_std_shared_ptr_Sl_sigrok_HardwareDevice_Sg__Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1HardwareDeviceVector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< std::shared_ptr< sigrok::HardwareDevice > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< std::shared_ptr< sigrok::HardwareDevice > > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1DeviceVector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Device > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (std::vector< std::shared_ptr< sigrok::Device > > *)new std::vector< std::shared_ptr< sigrok::Device > >();
  *(std::vector< std::shared_ptr< sigrok::Device > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1DeviceVector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Device > > *arg1 = 0 ;
  std::vector< std::shared_ptr< sigrok::Device > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Device > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::Device > > const & is null");
    return 0;
  } 
  result = (std::vector< std::shared_ptr< sigrok::Device > > *)new std::vector< std::shared_ptr< sigrok::Device > >((std::vector< std::shared_ptr< sigrok::Device > > const &)*arg1);
  *(std::vector< std::shared_ptr< sigrok::Device > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_DeviceVector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Device > > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Device > > **)&jarg1; 
  result = (bool)((std::vector< std::shared_ptr< sigrok::Device > > const *)arg1)->empty();
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_DeviceVector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< std::shared_ptr< sigrok::Device > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Device > > **)&jarg1; 
  (arg1)->clear();
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1DeviceVector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2) {
  jlong jresult = 0 ;
  jint arg1 ;
  std::shared_ptr< sigrok::Device > *arg2 = 0 ;
  std::vector< std::shared_ptr< sigrok::Device > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = jarg1; 
  arg2 = *(std::shared_ptr< sigrok::Device > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::shared_ptr< sigrok::Device > const & is null");
    return 0;
  } 
  try {
    result = (std::vector< std::shared_ptr< sigrok::Device > > *)new_std_vector_Sl_std_shared_ptr_Sl_sigrok_Device_Sg__Sg___SWIG_2(SWIG_STD_MOVE(arg1),(std::shared_ptr< sigrok::Device > const &)*arg2);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::Device > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_DeviceVector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Device > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Device > > **)&jarg1; 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_Device_Sg__Sg__doCapacity(arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_DeviceVector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< std::shared_ptr< sigrok::Device > > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Device > > **)&jarg1; 
  arg2 = jarg2; 
  try {
    std_vector_Sl_std_shared_ptr_Sl_sigrok_Device_Sg__Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::length_error &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_DeviceVector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Device > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Device > > **)&jarg1; 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_Device_Sg__Sg__doSize((std::vector< std::shared_ptr< sigrok::Device > > const *)arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_DeviceVector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< std::shared_ptr< sigrok::Device > > *arg1 = 0 ;
  std::vector< std::shared_ptr< sigrok::Device > >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Device > > **)&jarg1; 
  arg2 = *(std::vector< std::shared_ptr< sigrok::Device > >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::Device > >::value_type const & is null");
    return ;
  } 
  std_vector_Sl_std_shared_ptr_Sl_sigrok_Device_Sg__Sg__doAdd__SWIG_0(arg1,(std::shared_ptr< sigrok::Device > const &)*arg2);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_DeviceVector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  std::vector< std::shared_ptr< sigrok::Device > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::Device > >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Device > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::shared_ptr< sigrok::Device > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::Device > >::value_type const & is null");
    return ;
  } 
  try {
    std_vector_Sl_std_shared_ptr_Sl_sigrok_Device_Sg__Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(std::shared_ptr< sigrok::Device > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_DeviceVector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Device > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::Device > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Device > > **)&jarg1; 
  arg2 = jarg2; 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_Device_Sg__Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::Device > >::value_type **)&jresult = new std::vector< std::shared_ptr< sigrok::Device > >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_DeviceVector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Device > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::Device > >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Device > > **)&jarg1; 
  arg2 = jarg2; 
  try {
    result = (std::vector< std::shared_ptr< sigrok::Device > >::value_type *) &std_vector_Sl_std_shared_ptr_Sl_sigrok_Device_Sg__Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::Device > >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_DeviceVector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Device > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::Device > >::value_type *arg3 = 0 ;
  std::vector< std::shared_ptr< sigrok::Device > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Device > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::shared_ptr< sigrok::Device > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::Device > >::value_type const & is null");
    return 0;
  } 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_Device_Sg__Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(std::shared_ptr< sigrok::Device > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::Device > >::value_type **)&jresult = new std::vector< std::shared_ptr< sigrok::Device > >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_DeviceVector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< std::shared_ptr< sigrok::Device > > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Device > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  try {
    std_vector_Sl_std_shared_ptr_Sl_sigrok_Device_Sg__Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1DeviceVector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< std::shared_ptr< sigrok::Device > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Device > > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1ChannelVector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Channel > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (std::vector< std::shared_ptr< sigrok::Channel > > *)new std::vector< std::shared_ptr< sigrok::Channel > >();
  *(std::vector< std::shared_ptr< sigrok::Channel > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1ChannelVector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Channel > > *arg1 = 0 ;
  std::vector< std::shared_ptr< sigrok::Channel > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Channel > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::Channel > > const & is null");
    return 0;
  } 
  result = (std::vector< std::shared_ptr< sigrok::Channel > > *)new std::vector< std::shared_ptr< sigrok::Channel > >((std::vector< std::shared_ptr< sigrok::Channel > > const &)*arg1);
  *(std::vector< std::shared_ptr< sigrok::Channel > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelVector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Channel > > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Channel > > **)&jarg1; 
  result = (bool)((std::vector< std::shared_ptr< sigrok::Channel > > const *)arg1)->empty();
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelVector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< std::shared_ptr< sigrok::Channel > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Channel > > **)&jarg1; 
  (arg1)->clear();
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1ChannelVector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2) {
  jlong jresult = 0 ;
  jint arg1 ;
  std::shared_ptr< sigrok::Channel > *arg2 = 0 ;
  std::vector< std::shared_ptr< sigrok::Channel > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = jarg1; 
  arg2 = *(std::shared_ptr< sigrok::Channel > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::shared_ptr< sigrok::Channel > const & is null");
    return 0;
  } 
  try {
    result = (std::vector< std::shared_ptr< sigrok::Channel > > *)new_std_vector_Sl_std_shared_ptr_Sl_sigrok_Channel_Sg__Sg___SWIG_2(SWIG_STD_MOVE(arg1),(std::shared_ptr< sigrok::Channel > const &)*arg2);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::Channel > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelVector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Channel > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Channel > > **)&jarg1; 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_Channel_Sg__Sg__doCapacity(arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelVector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< std::shared_ptr< sigrok::Channel > > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Channel > > **)&jarg1; 
  arg2 = jarg2; 
  try {
    std_vector_Sl_std_shared_ptr_Sl_sigrok_Channel_Sg__Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::length_error &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelVector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Channel > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Channel > > **)&jarg1; 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_Channel_Sg__Sg__doSize((std::vector< std::shared_ptr< sigrok::Channel > > const *)arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelVector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< std::shared_ptr< sigrok::Channel > > *arg1 = 0 ;
  std::vector< std::shared_ptr< sigrok::Channel > >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Channel > > **)&jarg1; 
  arg2 = *(std::vector< std::shared_ptr< sigrok::Channel > >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::Channel > >::value_type const & is null");
    return ;
  } 
  std_vector_Sl_std_shared_ptr_Sl_sigrok_Channel_Sg__Sg__doAdd__SWIG_0(arg1,(std::shared_ptr< sigrok::Channel > const &)*arg2);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelVector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  std::vector< std::shared_ptr< sigrok::Channel > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::Channel > >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Channel > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::shared_ptr< sigrok::Channel > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::Channel > >::value_type const & is null");
    return ;
  } 
  try {
    std_vector_Sl_std_shared_ptr_Sl_sigrok_Channel_Sg__Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(std::shared_ptr< sigrok::Channel > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelVector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Channel > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::Channel > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Channel > > **)&jarg1; 
  arg2 = jarg2; 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_Channel_Sg__Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::Channel > >::value_type **)&jresult = new std::vector< std::shared_ptr< sigrok::Channel > >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelVector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Channel > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::Channel > >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Channel > > **)&jarg1; 
  arg2 = jarg2; 
  try {
    result = (std::vector< std::shared_ptr< sigrok::Channel > >::value_type *) &std_vector_Sl_std_shared_ptr_Sl_sigrok_Channel_Sg__Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::Channel > >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelVector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Channel > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::Channel > >::value_type *arg3 = 0 ;
  std::vector< std::shared_ptr< sigrok::Channel > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Channel > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::shared_ptr< sigrok::Channel > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::Channel > >::value_type const & is null");
    return 0;
  } 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_Channel_Sg__Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(std::shared_ptr< sigrok::Channel > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::Channel > >::value_type **)&jresult = new std::vector< std::shared_ptr< sigrok::Channel > >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelVector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< std::shared_ptr< sigrok::Channel > > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Channel > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  try {
    std_vector_Sl_std_shared_ptr_Sl_sigrok_Channel_Sg__Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1ChannelVector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< std::shared_ptr< sigrok::Channel > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Channel > > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1ChannelGroupMap_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > *)new std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >();
  *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1ChannelGroupMap_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > const & is null");
    return 0;
  } 
  result = (std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > *)new std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >((std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > const &)*arg1);
  *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelGroupMap_1Iterator_1getNextUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup >,std::less< std::string > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator **)&jarg1; 
  result = std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_ChannelGroup_Sg__Sg__iterator_getNextUnchecked(arg1);
  *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup >,std::less< std::string > >::iterator **)&jresult = new std::map< std::string,std::shared_ptr< sigrok::ChannelGroup >,std::less< std::string > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelGroupMap_1Iterator_1isNot(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator arg2 ;
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator **)&jarg1; 
  argp2 = *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator");
    return 0;
  }
  arg2 = *argp2; 
  result = (bool)std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_ChannelGroup_Sg__Sg__iterator_isNot((std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator const *)arg1,SWIG_STD_MOVE(arg2));
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelGroupMap_1Iterator_1getKey(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator **)&jarg1; 
  result = std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_ChannelGroup_Sg__Sg__iterator_getKey((std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator const *)arg1);
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelGroupMap_1Iterator_1getValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator *arg1 = 0 ;
  std::shared_ptr< sigrok::ChannelGroup > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator **)&jarg1; 
  result = std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_ChannelGroup_Sg__Sg__iterator_getValue((std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator const *)arg1);
  *(std::shared_ptr< sigrok::ChannelGroup > **)&jresult = new std::shared_ptr< sigrok::ChannelGroup >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelGroupMap_1Iterator_1setValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator *arg1 = 0 ;
  std::shared_ptr< sigrok::ChannelGroup > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator **)&jarg1; 
  arg2 = *(std::shared_ptr< sigrok::ChannelGroup > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::shared_ptr< sigrok::ChannelGroup > const & is null");
    return ;
  } 
  std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_ChannelGroup_Sg__Sg__iterator_setValue(arg1,(std::shared_ptr< sigrok::ChannelGroup > const &)*arg2);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1ChannelGroupMap_1Iterator(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelGroupMap_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > **)&jarg1; 
  result = (bool)((std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > const *)arg1)->empty();
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelGroupMap_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > **)&jarg1; 
  (arg1)->clear();
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelGroupMap_1find(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  result = (arg1)->find((std::string const &)*arg2);
  *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator **)&jresult = new std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelGroupMap_1begin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > **)&jarg1; 
  result = (arg1)->begin();
  *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator **)&jresult = new std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelGroupMap_1end(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > **)&jarg1; 
  result = (arg1)->end();
  *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator **)&jresult = new std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelGroupMap_1sizeImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > **)&jarg1; 
  try {
    result = std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_ChannelGroup_Sg__Sg__sizeImpl((std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > const *)arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelGroupMap_1containsImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jboolean jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  result = (bool)std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_ChannelGroup_Sg__Sg__containsImpl(arg1,(std::string const &)*arg2);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelGroupMap_1putUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3) {
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::shared_ptr< sigrok::ChannelGroup > *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = *(std::shared_ptr< sigrok::ChannelGroup > **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::shared_ptr< sigrok::ChannelGroup > const & is null");
    return ;
  } 
  std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_ChannelGroup_Sg__Sg__putUnchecked(arg1,(std::string const &)*arg2,(std::shared_ptr< sigrok::ChannelGroup > const &)*arg3);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelGroupMap_1removeUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup >,std::less< std::string > >::iterator arg2 ;
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup >,std::less< std::string > >::iterator const *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > **)&jarg1; 
  argp2 = *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup >,std::less< std::string > >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,std::shared_ptr< sigrok::ChannelGroup >,std::less< std::string > >::iterator const");
    return ;
  }
  arg2 = *argp2; 
  std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_ChannelGroup_Sg__Sg__removeUnchecked(arg1,SWIG_STD_MOVE(arg2));
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1ChannelGroupMap(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup > > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1ConfigVector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< sigrok::ConfigKey const * > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (std::vector< sigrok::ConfigKey const * > *)new std::vector< sigrok::ConfigKey const * >();
  *(std::vector< sigrok::ConfigKey const * > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1ConfigVector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< sigrok::ConfigKey const * > *arg1 = 0 ;
  std::vector< sigrok::ConfigKey const * > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::ConfigKey const * > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< sigrok::ConfigKey const * > const & is null");
    return 0;
  } 
  result = (std::vector< sigrok::ConfigKey const * > *)new std::vector< sigrok::ConfigKey const * >((std::vector< sigrok::ConfigKey const * > const &)*arg1);
  *(std::vector< sigrok::ConfigKey const * > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigVector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< sigrok::ConfigKey const * > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::ConfigKey const * > **)&jarg1; 
  result = (bool)((std::vector< sigrok::ConfigKey const * > const *)arg1)->empty();
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigVector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< sigrok::ConfigKey const * > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::ConfigKey const * > **)&jarg1; 
  (arg1)->clear();
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1ConfigVector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  sigrok::ConfigKey **arg2 = 0 ;
  sigrok::ConfigKey *temp2 = 0 ;
  std::vector< sigrok::ConfigKey const * > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  temp2 = *(sigrok::ConfigKey **)&jarg2;
  arg2 = (sigrok::ConfigKey **)&temp2; 
  try {
    result = (std::vector< sigrok::ConfigKey const * > *)new_std_vector_Sl_sigrok_ConfigKey_SS_const_Sm__Sg___SWIG_2(SWIG_STD_MOVE(arg1),(sigrok::ConfigKey const *const &)*arg2);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< sigrok::ConfigKey const * > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigVector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< sigrok::ConfigKey const * > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::ConfigKey const * > **)&jarg1; 
  try {
    result = std_vector_Sl_sigrok_ConfigKey_SS_const_Sm__Sg__doCapacity(arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigVector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< sigrok::ConfigKey const * > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::ConfigKey const * > **)&jarg1; 
  arg2 = jarg2; 
  try {
    std_vector_Sl_sigrok_ConfigKey_SS_const_Sm__Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::length_error &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigVector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< sigrok::ConfigKey const * > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::ConfigKey const * > **)&jarg1; 
  try {
    result = std_vector_Sl_sigrok_ConfigKey_SS_const_Sm__Sg__doSize((std::vector< sigrok::ConfigKey const * > const *)arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigVector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< sigrok::ConfigKey const * > *arg1 = 0 ;
  std::vector< sigrok::ConfigKey const * >::value_type *arg2 = 0 ;
  std::vector< sigrok::ConfigKey const * >::value_type temp2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< sigrok::ConfigKey const * > **)&jarg1; 
  temp2 = *(std::vector< sigrok::ConfigKey const * >::value_type *)&jarg2;
  arg2 = (std::vector< sigrok::ConfigKey const * >::value_type *)&temp2; 
  std_vector_Sl_sigrok_ConfigKey_SS_const_Sm__Sg__doAdd__SWIG_0(arg1,(sigrok::ConfigKey const *const &)*arg2);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigVector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< sigrok::ConfigKey const * > *arg1 = 0 ;
  jint arg2 ;
  std::vector< sigrok::ConfigKey const * >::value_type *arg3 = 0 ;
  std::vector< sigrok::ConfigKey const * >::value_type temp3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< sigrok::ConfigKey const * > **)&jarg1; 
  arg2 = jarg2; 
  temp3 = *(std::vector< sigrok::ConfigKey const * >::value_type *)&jarg3;
  arg3 = (std::vector< sigrok::ConfigKey const * >::value_type *)&temp3; 
  try {
    std_vector_Sl_sigrok_ConfigKey_SS_const_Sm__Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(sigrok::ConfigKey const *const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigVector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< sigrok::ConfigKey const * > *arg1 = 0 ;
  jint arg2 ;
  std::vector< sigrok::ConfigKey const * >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::ConfigKey const * > **)&jarg1; 
  arg2 = jarg2; 
  try {
    result = (std::vector< sigrok::ConfigKey const * >::value_type)std_vector_Sl_sigrok_ConfigKey_SS_const_Sm__Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< sigrok::ConfigKey const * >::value_type *)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigVector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< sigrok::ConfigKey const * > *arg1 = 0 ;
  jint arg2 ;
  std::vector< sigrok::ConfigKey const * >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::ConfigKey const * > **)&jarg1; 
  arg2 = jarg2; 
  try {
    result = (std::vector< sigrok::ConfigKey const * >::value_type *) &std_vector_Sl_sigrok_ConfigKey_SS_const_Sm__Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< sigrok::ConfigKey const * >::value_type *)&jresult = *result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigVector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< sigrok::ConfigKey const * > *arg1 = 0 ;
  jint arg2 ;
  std::vector< sigrok::ConfigKey const * >::value_type *arg3 = 0 ;
  std::vector< sigrok::ConfigKey const * >::value_type temp3 = 0 ;
  std::vector< sigrok::ConfigKey const * >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< sigrok::ConfigKey const * > **)&jarg1; 
  arg2 = jarg2; 
  temp3 = *(std::vector< sigrok::ConfigKey const * >::value_type *)&jarg3;
  arg3 = (std::vector< sigrok::ConfigKey const * >::value_type *)&temp3; 
  try {
    result = (std::vector< sigrok::ConfigKey const * >::value_type)std_vector_Sl_sigrok_ConfigKey_SS_const_Sm__Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(sigrok::ConfigKey const *const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< sigrok::ConfigKey const * >::value_type *)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigVector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< sigrok::ConfigKey const * > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::ConfigKey const * > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  try {
    std_vector_Sl_sigrok_ConfigKey_SS_const_Sm__Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1ConfigVector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< sigrok::ConfigKey const * > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< sigrok::ConfigKey const * > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1ConfigMap_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::map< sigrok::ConfigKey const *,Glib::VariantBase > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (std::map< sigrok::ConfigKey const *,Glib::VariantBase > *)new std::map< sigrok::ConfigKey const *,Glib::VariantBase >();
  *(std::map< sigrok::ConfigKey const *,Glib::VariantBase > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1ConfigMap_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< sigrok::ConfigKey const *,Glib::VariantBase > *arg1 = 0 ;
  std::map< sigrok::ConfigKey const *,Glib::VariantBase > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< sigrok::ConfigKey const *,Glib::VariantBase > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::map< sigrok::ConfigKey const *,Glib::VariantBase > const & is null");
    return 0;
  } 
  result = (std::map< sigrok::ConfigKey const *,Glib::VariantBase > *)new std::map< sigrok::ConfigKey const *,Glib::VariantBase >((std::map< sigrok::ConfigKey const *,Glib::VariantBase > const &)*arg1);
  *(std::map< sigrok::ConfigKey const *,Glib::VariantBase > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigMap_1Iterator_1getNextUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator *arg1 = 0 ;
  std::map< sigrok::ConfigKey const *,Glib::VariantBase,std::less< sigrok::ConfigKey const * > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator **)&jarg1; 
  result = std_map_Sl_sigrok_ConfigKey_SS_const_Sm__Sc_Glib_VariantBase_Sg__iterator_getNextUnchecked(arg1);
  *(std::map< sigrok::ConfigKey const *,Glib::VariantBase,std::less< sigrok::ConfigKey const * > >::iterator **)&jresult = new std::map< sigrok::ConfigKey const *,Glib::VariantBase,std::less< sigrok::ConfigKey const * > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigMap_1Iterator_1isNot(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator *arg1 = 0 ;
  std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator arg2 ;
  std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator **)&jarg1; 
  argp2 = *(std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator");
    return 0;
  }
  arg2 = *argp2; 
  result = (bool)std_map_Sl_sigrok_ConfigKey_SS_const_Sm__Sc_Glib_VariantBase_Sg__iterator_isNot((std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator const *)arg1,SWIG_STD_MOVE(arg2));
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigMap_1Iterator_1getKey(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator *arg1 = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator **)&jarg1; 
  result = (sigrok::ConfigKey *)std_map_Sl_sigrok_ConfigKey_SS_const_Sm__Sc_Glib_VariantBase_Sg__iterator_getKey((std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator const *)arg1);
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigMap_1Iterator_1getValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator *arg1 = 0 ;
  Glib::VariantBase result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator **)&jarg1; 
  result = std_map_Sl_sigrok_ConfigKey_SS_const_Sm__Sc_Glib_VariantBase_Sg__iterator_getValue((std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator const *)arg1);
  *(Glib::VariantBase **)&jresult = new Glib::VariantBase(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigMap_1Iterator_1setValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator *arg1 = 0 ;
  Glib::VariantBase *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator **)&jarg1; 
  arg2 = *(Glib::VariantBase **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Glib::VariantBase const & is null");
    return ;
  } 
  std_map_Sl_sigrok_ConfigKey_SS_const_Sm__Sc_Glib_VariantBase_Sg__iterator_setValue(arg1,(Glib::VariantBase const &)*arg2);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1ConfigMap_1Iterator(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigMap_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::map< sigrok::ConfigKey const *,Glib::VariantBase > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< sigrok::ConfigKey const *,Glib::VariantBase > **)&jarg1; 
  result = (bool)((std::map< sigrok::ConfigKey const *,Glib::VariantBase > const *)arg1)->empty();
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigMap_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::map< sigrok::ConfigKey const *,Glib::VariantBase > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< sigrok::ConfigKey const *,Glib::VariantBase > **)&jarg1; 
  (arg1)->clear();
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigMap_1find(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  std::map< sigrok::ConfigKey const *,Glib::VariantBase > *arg1 = 0 ;
  sigrok::ConfigKey **arg2 = 0 ;
  sigrok::ConfigKey *temp2 = 0 ;
  std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< sigrok::ConfigKey const *,Glib::VariantBase > **)&jarg1; 
  temp2 = *(sigrok::ConfigKey **)&jarg2;
  arg2 = (sigrok::ConfigKey **)&temp2; 
  result = (arg1)->find((sigrok::ConfigKey const *const &)*arg2);
  *(std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator **)&jresult = new std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigMap_1begin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< sigrok::ConfigKey const *,Glib::VariantBase > *arg1 = 0 ;
  std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< sigrok::ConfigKey const *,Glib::VariantBase > **)&jarg1; 
  result = (arg1)->begin();
  *(std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator **)&jresult = new std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigMap_1end(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< sigrok::ConfigKey const *,Glib::VariantBase > *arg1 = 0 ;
  std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< sigrok::ConfigKey const *,Glib::VariantBase > **)&jarg1; 
  result = (arg1)->end();
  *(std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator **)&jresult = new std::map< sigrok::ConfigKey const *,Glib::VariantBase >::iterator(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigMap_1sizeImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::map< sigrok::ConfigKey const *,Glib::VariantBase > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< sigrok::ConfigKey const *,Glib::VariantBase > **)&jarg1; 
  try {
    result = std_map_Sl_sigrok_ConfigKey_SS_const_Sm__Sc_Glib_VariantBase_Sg__sizeImpl((std::map< sigrok::ConfigKey const *,Glib::VariantBase > const *)arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigMap_1containsImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  std::map< sigrok::ConfigKey const *,Glib::VariantBase > *arg1 = 0 ;
  sigrok::ConfigKey **arg2 = 0 ;
  sigrok::ConfigKey *temp2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< sigrok::ConfigKey const *,Glib::VariantBase > **)&jarg1; 
  temp2 = *(sigrok::ConfigKey **)&jarg2;
  arg2 = (sigrok::ConfigKey **)&temp2; 
  result = (bool)std_map_Sl_sigrok_ConfigKey_SS_const_Sm__Sc_Glib_VariantBase_Sg__containsImpl(arg1,(sigrok::ConfigKey const *const &)*arg2);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigMap_1putUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
  std::map< sigrok::ConfigKey const *,Glib::VariantBase > *arg1 = 0 ;
  sigrok::ConfigKey **arg2 = 0 ;
  Glib::VariantBase *arg3 = 0 ;
  sigrok::ConfigKey *temp2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  arg1 = *(std::map< sigrok::ConfigKey const *,Glib::VariantBase > **)&jarg1; 
  temp2 = *(sigrok::ConfigKey **)&jarg2;
  arg2 = (sigrok::ConfigKey **)&temp2; 
  arg3 = *(Glib::VariantBase **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Glib::VariantBase const & is null");
    return ;
  } 
  std_map_Sl_sigrok_ConfigKey_SS_const_Sm__Sc_Glib_VariantBase_Sg__putUnchecked(arg1,(sigrok::ConfigKey const *const &)*arg2,(Glib::VariantBase const &)*arg3);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigMap_1removeUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::map< sigrok::ConfigKey const *,Glib::VariantBase > *arg1 = 0 ;
  std::map< sigrok::ConfigKey const *,Glib::VariantBase,std::less< sigrok::ConfigKey const * > >::iterator arg2 ;
  std::map< sigrok::ConfigKey const *,Glib::VariantBase,std::less< sigrok::ConfigKey const * > >::iterator const *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< sigrok::ConfigKey const *,Glib::VariantBase > **)&jarg1; 
  argp2 = *(std::map< sigrok::ConfigKey const *,Glib::VariantBase,std::less< sigrok::ConfigKey const * > >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< sigrok::ConfigKey const *,Glib::VariantBase,std::less< sigrok::ConfigKey const * > >::iterator const");
    return ;
  }
  arg2 = *argp2; 
  std_map_Sl_sigrok_ConfigKey_SS_const_Sm__Sc_Glib_VariantBase_Sg__removeUnchecked(arg1,SWIG_STD_MOVE(arg2));
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1ConfigMap(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< sigrok::ConfigKey const *,Glib::VariantBase > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< sigrok::ConfigKey const *,Glib::VariantBase > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1ConfigSet(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::set< sigrok::ConfigKey const * > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::set< sigrok::ConfigKey const * > *)new std::set< sigrok::ConfigKey const * >();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::set< sigrok::ConfigKey const * > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1ConfigSet(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::set< sigrok::ConfigKey const * > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::set< sigrok::ConfigKey const * > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1CapabilityVector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< sigrok::Capability const * > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (std::vector< sigrok::Capability const * > *)new std::vector< sigrok::Capability const * >();
  *(std::vector< sigrok::Capability const * > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1CapabilityVector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< sigrok::Capability const * > *arg1 = 0 ;
  std::vector< sigrok::Capability const * > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::Capability const * > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< sigrok::Capability const * > const & is null");
    return 0;
  } 
  result = (std::vector< sigrok::Capability const * > *)new std::vector< sigrok::Capability const * >((std::vector< sigrok::Capability const * > const &)*arg1);
  *(std::vector< sigrok::Capability const * > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_CapabilityVector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< sigrok::Capability const * > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::Capability const * > **)&jarg1; 
  result = (bool)((std::vector< sigrok::Capability const * > const *)arg1)->empty();
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_CapabilityVector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< sigrok::Capability const * > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::Capability const * > **)&jarg1; 
  (arg1)->clear();
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1CapabilityVector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  sigrok::Capability **arg2 = 0 ;
  sigrok::Capability *temp2 = 0 ;
  std::vector< sigrok::Capability const * > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  temp2 = *(sigrok::Capability **)&jarg2;
  arg2 = (sigrok::Capability **)&temp2; 
  try {
    result = (std::vector< sigrok::Capability const * > *)new_std_vector_Sl_sigrok_Capability_SS_const_Sm__Sg___SWIG_2(SWIG_STD_MOVE(arg1),(sigrok::Capability const *const &)*arg2);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< sigrok::Capability const * > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_CapabilityVector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< sigrok::Capability const * > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::Capability const * > **)&jarg1; 
  try {
    result = std_vector_Sl_sigrok_Capability_SS_const_Sm__Sg__doCapacity(arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_CapabilityVector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< sigrok::Capability const * > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::Capability const * > **)&jarg1; 
  arg2 = jarg2; 
  try {
    std_vector_Sl_sigrok_Capability_SS_const_Sm__Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::length_error &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_CapabilityVector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< sigrok::Capability const * > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::Capability const * > **)&jarg1; 
  try {
    result = std_vector_Sl_sigrok_Capability_SS_const_Sm__Sg__doSize((std::vector< sigrok::Capability const * > const *)arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_CapabilityVector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< sigrok::Capability const * > *arg1 = 0 ;
  std::vector< sigrok::Capability const * >::value_type *arg2 = 0 ;
  std::vector< sigrok::Capability const * >::value_type temp2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< sigrok::Capability const * > **)&jarg1; 
  temp2 = *(std::vector< sigrok::Capability const * >::value_type *)&jarg2;
  arg2 = (std::vector< sigrok::Capability const * >::value_type *)&temp2; 
  std_vector_Sl_sigrok_Capability_SS_const_Sm__Sg__doAdd__SWIG_0(arg1,(sigrok::Capability const *const &)*arg2);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_CapabilityVector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< sigrok::Capability const * > *arg1 = 0 ;
  jint arg2 ;
  std::vector< sigrok::Capability const * >::value_type *arg3 = 0 ;
  std::vector< sigrok::Capability const * >::value_type temp3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< sigrok::Capability const * > **)&jarg1; 
  arg2 = jarg2; 
  temp3 = *(std::vector< sigrok::Capability const * >::value_type *)&jarg3;
  arg3 = (std::vector< sigrok::Capability const * >::value_type *)&temp3; 
  try {
    std_vector_Sl_sigrok_Capability_SS_const_Sm__Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(sigrok::Capability const *const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_CapabilityVector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< sigrok::Capability const * > *arg1 = 0 ;
  jint arg2 ;
  std::vector< sigrok::Capability const * >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::Capability const * > **)&jarg1; 
  arg2 = jarg2; 
  try {
    result = (std::vector< sigrok::Capability const * >::value_type)std_vector_Sl_sigrok_Capability_SS_const_Sm__Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< sigrok::Capability const * >::value_type *)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_CapabilityVector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< sigrok::Capability const * > *arg1 = 0 ;
  jint arg2 ;
  std::vector< sigrok::Capability const * >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::Capability const * > **)&jarg1; 
  arg2 = jarg2; 
  try {
    result = (std::vector< sigrok::Capability const * >::value_type *) &std_vector_Sl_sigrok_Capability_SS_const_Sm__Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< sigrok::Capability const * >::value_type *)&jresult = *result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_CapabilityVector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< sigrok::Capability const * > *arg1 = 0 ;
  jint arg2 ;
  std::vector< sigrok::Capability const * >::value_type *arg3 = 0 ;
  std::vector< sigrok::Capability const * >::value_type temp3 = 0 ;
  std::vector< sigrok::Capability const * >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< sigrok::Capability const * > **)&jarg1; 
  arg2 = jarg2; 
  temp3 = *(std::vector< sigrok::Capability const * >::value_type *)&jarg3;
  arg3 = (std::vector< sigrok::Capability const * >::value_type *)&temp3; 
  try {
    result = (std::vector< sigrok::Capability const * >::value_type)std_vector_Sl_sigrok_Capability_SS_const_Sm__Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(sigrok::Capability const *const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< sigrok::Capability const * >::value_type *)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_CapabilityVector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< sigrok::Capability const * > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::Capability const * > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  try {
    std_vector_Sl_sigrok_Capability_SS_const_Sm__Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1CapabilityVector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< sigrok::Capability const * > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< sigrok::Capability const * > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1CapabilitySet(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::set< sigrok::Capability const * > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::set< sigrok::Capability const * > *)new std::set< sigrok::Capability const * >();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::set< sigrok::Capability const * > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1CapabilitySet(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::set< sigrok::Capability const * > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::set< sigrok::Capability const * > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1OptionVector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Option > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (std::vector< std::shared_ptr< sigrok::Option > > *)new std::vector< std::shared_ptr< sigrok::Option > >();
  *(std::vector< std::shared_ptr< sigrok::Option > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1OptionVector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  std::vector< std::shared_ptr< sigrok::Option > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Option > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::Option > > const & is null");
    return 0;
  } 
  result = (std::vector< std::shared_ptr< sigrok::Option > > *)new std::vector< std::shared_ptr< sigrok::Option > >((std::vector< std::shared_ptr< sigrok::Option > > const &)*arg1);
  *(std::vector< std::shared_ptr< sigrok::Option > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_OptionVector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Option > > **)&jarg1; 
  result = (bool)((std::vector< std::shared_ptr< sigrok::Option > > const *)arg1)->empty();
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_OptionVector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Option > > **)&jarg1; 
  (arg1)->clear();
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1OptionVector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2) {
  jlong jresult = 0 ;
  jint arg1 ;
  std::shared_ptr< sigrok::Option > *arg2 = 0 ;
  std::vector< std::shared_ptr< sigrok::Option > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = jarg1; 
  arg2 = *(std::shared_ptr< sigrok::Option > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::shared_ptr< sigrok::Option > const & is null");
    return 0;
  } 
  try {
    result = (std::vector< std::shared_ptr< sigrok::Option > > *)new_std_vector_Sl_std_shared_ptr_Sl_sigrok_Option_Sg__Sg___SWIG_2(SWIG_STD_MOVE(arg1),(std::shared_ptr< sigrok::Option > const &)*arg2);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::Option > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_OptionVector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Option > > **)&jarg1; 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__doCapacity(arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_OptionVector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Option > > **)&jarg1; 
  arg2 = jarg2; 
  try {
    std_vector_Sl_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::length_error &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_OptionVector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Option > > **)&jarg1; 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__doSize((std::vector< std::shared_ptr< sigrok::Option > > const *)arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_OptionVector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  std::vector< std::shared_ptr< sigrok::Option > >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Option > > **)&jarg1; 
  arg2 = *(std::vector< std::shared_ptr< sigrok::Option > >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::Option > >::value_type const & is null");
    return ;
  } 
  std_vector_Sl_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__doAdd__SWIG_0(arg1,(std::shared_ptr< sigrok::Option > const &)*arg2);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_OptionVector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  std::vector< std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::Option > >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Option > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::shared_ptr< sigrok::Option > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::Option > >::value_type const & is null");
    return ;
  } 
  try {
    std_vector_Sl_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(std::shared_ptr< sigrok::Option > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_OptionVector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::Option > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Option > > **)&jarg1; 
  arg2 = jarg2; 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::Option > >::value_type **)&jresult = new std::vector< std::shared_ptr< sigrok::Option > >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_OptionVector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::Option > >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Option > > **)&jarg1; 
  arg2 = jarg2; 
  try {
    result = (std::vector< std::shared_ptr< sigrok::Option > >::value_type *) &std_vector_Sl_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::Option > >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_OptionVector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::Option > >::value_type *arg3 = 0 ;
  std::vector< std::shared_ptr< sigrok::Option > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Option > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::shared_ptr< sigrok::Option > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::Option > >::value_type const & is null");
    return 0;
  } 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(std::shared_ptr< sigrok::Option > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::Option > >::value_type **)&jresult = new std::vector< std::shared_ptr< sigrok::Option > >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_OptionVector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Option > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  try {
    std_vector_Sl_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1OptionVector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< std::shared_ptr< sigrok::Option > > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1OptionMap_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Option > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (std::map< std::string,std::shared_ptr< sigrok::Option > > *)new std::map< std::string,std::shared_ptr< sigrok::Option > >();
  *(std::map< std::string,std::shared_ptr< sigrok::Option > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1OptionMap_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Option > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Option > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::map< std::string,std::shared_ptr< sigrok::Option > > const & is null");
    return 0;
  } 
  result = (std::map< std::string,std::shared_ptr< sigrok::Option > > *)new std::map< std::string,std::shared_ptr< sigrok::Option > >((std::map< std::string,std::shared_ptr< sigrok::Option > > const &)*arg1);
  *(std::map< std::string,std::shared_ptr< sigrok::Option > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_OptionMap_1Iterator_1getNextUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Option >,std::less< std::string > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator **)&jarg1; 
  result = std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__iterator_getNextUnchecked(arg1);
  *(std::map< std::string,std::shared_ptr< sigrok::Option >,std::less< std::string > >::iterator **)&jresult = new std::map< std::string,std::shared_ptr< sigrok::Option >,std::less< std::string > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_OptionMap_1Iterator_1isNot(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator arg2 ;
  std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator **)&jarg1; 
  argp2 = *(std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator");
    return 0;
  }
  arg2 = *argp2; 
  result = (bool)std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__iterator_isNot((std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator const *)arg1,SWIG_STD_MOVE(arg2));
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_OptionMap_1Iterator_1getKey(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator **)&jarg1; 
  result = std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__iterator_getKey((std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator const *)arg1);
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_OptionMap_1Iterator_1getValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator *arg1 = 0 ;
  std::shared_ptr< sigrok::Option > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator **)&jarg1; 
  result = std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__iterator_getValue((std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator const *)arg1);
  *(std::shared_ptr< sigrok::Option > **)&jresult = new std::shared_ptr< sigrok::Option >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_OptionMap_1Iterator_1setValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator *arg1 = 0 ;
  std::shared_ptr< sigrok::Option > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator **)&jarg1; 
  arg2 = *(std::shared_ptr< sigrok::Option > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::shared_ptr< sigrok::Option > const & is null");
    return ;
  } 
  std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__iterator_setValue(arg1,(std::shared_ptr< sigrok::Option > const &)*arg2);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1OptionMap_1Iterator(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_OptionMap_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Option > > **)&jarg1; 
  result = (bool)((std::map< std::string,std::shared_ptr< sigrok::Option > > const *)arg1)->empty();
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_OptionMap_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::map< std::string,std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Option > > **)&jarg1; 
  (arg1)->clear();
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_OptionMap_1find(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Option > > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  result = (arg1)->find((std::string const &)*arg2);
  *(std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator **)&jresult = new std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_OptionMap_1begin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Option > > **)&jarg1; 
  result = (arg1)->begin();
  *(std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator **)&jresult = new std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_OptionMap_1end(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Option > > **)&jarg1; 
  result = (arg1)->end();
  *(std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator **)&jresult = new std::map< std::string,std::shared_ptr< sigrok::Option > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_OptionMap_1sizeImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Option > > **)&jarg1; 
  try {
    result = std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__sizeImpl((std::map< std::string,std::shared_ptr< sigrok::Option > > const *)arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_OptionMap_1containsImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jboolean jresult = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Option > > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  result = (bool)std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__containsImpl(arg1,(std::string const &)*arg2);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_OptionMap_1putUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3) {
  std::map< std::string,std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::shared_ptr< sigrok::Option > *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Option > > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = *(std::shared_ptr< sigrok::Option > **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::shared_ptr< sigrok::Option > const & is null");
    return ;
  } 
  std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__putUnchecked(arg1,(std::string const &)*arg2,(std::shared_ptr< sigrok::Option > const &)*arg3);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_OptionMap_1removeUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::map< std::string,std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Option >,std::less< std::string > >::iterator arg2 ;
  std::map< std::string,std::shared_ptr< sigrok::Option >,std::less< std::string > >::iterator const *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Option > > **)&jarg1; 
  argp2 = *(std::map< std::string,std::shared_ptr< sigrok::Option >,std::less< std::string > >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,std::shared_ptr< sigrok::Option >,std::less< std::string > >::iterator const");
    return ;
  }
  arg2 = *argp2; 
  std_map_Sl_std_string_Sc_std_shared_ptr_Sl_sigrok_Option_Sg__Sg__removeUnchecked(arg1,SWIG_STD_MOVE(arg2));
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1OptionMap(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< std::string,std::shared_ptr< sigrok::Option > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< std::string,std::shared_ptr< sigrok::Option > > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1VariantVector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< Glib::VariantBase > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (std::vector< Glib::VariantBase > *)new std::vector< Glib::VariantBase >();
  *(std::vector< Glib::VariantBase > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1VariantVector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< Glib::VariantBase > *arg1 = 0 ;
  std::vector< Glib::VariantBase > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< Glib::VariantBase > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< Glib::VariantBase > const & is null");
    return 0;
  } 
  result = (std::vector< Glib::VariantBase > *)new std::vector< Glib::VariantBase >((std::vector< Glib::VariantBase > const &)*arg1);
  *(std::vector< Glib::VariantBase > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_VariantVector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< Glib::VariantBase > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< Glib::VariantBase > **)&jarg1; 
  result = (bool)((std::vector< Glib::VariantBase > const *)arg1)->empty();
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_VariantVector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< Glib::VariantBase > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< Glib::VariantBase > **)&jarg1; 
  (arg1)->clear();
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1VariantVector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  Glib::VariantBase *arg2 = 0 ;
  std::vector< Glib::VariantBase > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(Glib::VariantBase **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Glib::VariantBase const & is null");
    return 0;
  } 
  try {
    result = (std::vector< Glib::VariantBase > *)new_std_vector_Sl_Glib_VariantBase_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(Glib::VariantBase const &)*arg2);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< Glib::VariantBase > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_VariantVector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< Glib::VariantBase > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< Glib::VariantBase > **)&jarg1; 
  try {
    result = std_vector_Sl_Glib_VariantBase_Sg__doCapacity(arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_VariantVector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< Glib::VariantBase > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< Glib::VariantBase > **)&jarg1; 
  arg2 = jarg2; 
  try {
    std_vector_Sl_Glib_VariantBase_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::length_error &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_VariantVector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< Glib::VariantBase > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< Glib::VariantBase > **)&jarg1; 
  try {
    result = std_vector_Sl_Glib_VariantBase_Sg__doSize((std::vector< Glib::VariantBase > const *)arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_VariantVector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< Glib::VariantBase > *arg1 = 0 ;
  std::vector< Glib::VariantBase >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< Glib::VariantBase > **)&jarg1; 
  arg2 = *(std::vector< Glib::VariantBase >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< Glib::VariantBase >::value_type const & is null");
    return ;
  } 
  std_vector_Sl_Glib_VariantBase_Sg__doAdd__SWIG_0(arg1,(Glib::VariantBase const &)*arg2);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_VariantVector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< Glib::VariantBase > *arg1 = 0 ;
  jint arg2 ;
  std::vector< Glib::VariantBase >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< Glib::VariantBase > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< Glib::VariantBase >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< Glib::VariantBase >::value_type const & is null");
    return ;
  } 
  try {
    std_vector_Sl_Glib_VariantBase_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(Glib::VariantBase const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_VariantVector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< Glib::VariantBase > *arg1 = 0 ;
  jint arg2 ;
  std::vector< Glib::VariantBase >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< Glib::VariantBase > **)&jarg1; 
  arg2 = jarg2; 
  try {
    result = std_vector_Sl_Glib_VariantBase_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< Glib::VariantBase >::value_type **)&jresult = new std::vector< Glib::VariantBase >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_VariantVector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< Glib::VariantBase > *arg1 = 0 ;
  jint arg2 ;
  std::vector< Glib::VariantBase >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< Glib::VariantBase > **)&jarg1; 
  arg2 = jarg2; 
  try {
    result = (std::vector< Glib::VariantBase >::value_type *) &std_vector_Sl_Glib_VariantBase_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< Glib::VariantBase >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_VariantVector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< Glib::VariantBase > *arg1 = 0 ;
  jint arg2 ;
  std::vector< Glib::VariantBase >::value_type *arg3 = 0 ;
  std::vector< Glib::VariantBase >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< Glib::VariantBase > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< Glib::VariantBase >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< Glib::VariantBase >::value_type const & is null");
    return 0;
  } 
  try {
    result = std_vector_Sl_Glib_VariantBase_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(Glib::VariantBase const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< Glib::VariantBase >::value_type **)&jresult = new std::vector< Glib::VariantBase >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_VariantVector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< Glib::VariantBase > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< Glib::VariantBase > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  try {
    std_vector_Sl_Glib_VariantBase_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1VariantVector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< Glib::VariantBase > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< Glib::VariantBase > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1VariantMap_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::map< std::string,Glib::VariantBase > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (std::map< std::string,Glib::VariantBase > *)new std::map< std::string,Glib::VariantBase >();
  *(std::map< std::string,Glib::VariantBase > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1VariantMap_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,Glib::VariantBase > *arg1 = 0 ;
  std::map< std::string,Glib::VariantBase > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,Glib::VariantBase > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::map< std::string,Glib::VariantBase > const & is null");
    return 0;
  } 
  result = (std::map< std::string,Glib::VariantBase > *)new std::map< std::string,Glib::VariantBase >((std::map< std::string,Glib::VariantBase > const &)*arg1);
  *(std::map< std::string,Glib::VariantBase > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_VariantMap_1Iterator_1getNextUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,Glib::VariantBase >::iterator *arg1 = 0 ;
  std::map< std::string,Glib::VariantBase,std::less< std::string > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,Glib::VariantBase >::iterator **)&jarg1; 
  result = std_map_Sl_std_string_Sc_Glib_VariantBase_Sg__iterator_getNextUnchecked(arg1);
  *(std::map< std::string,Glib::VariantBase,std::less< std::string > >::iterator **)&jresult = new std::map< std::string,Glib::VariantBase,std::less< std::string > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_VariantMap_1Iterator_1isNot(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  std::map< std::string,Glib::VariantBase >::iterator *arg1 = 0 ;
  std::map< std::string,Glib::VariantBase >::iterator arg2 ;
  std::map< std::string,Glib::VariantBase >::iterator *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< std::string,Glib::VariantBase >::iterator **)&jarg1; 
  argp2 = *(std::map< std::string,Glib::VariantBase >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,Glib::VariantBase >::iterator");
    return 0;
  }
  arg2 = *argp2; 
  result = (bool)std_map_Sl_std_string_Sc_Glib_VariantBase_Sg__iterator_isNot((std::map< std::string,Glib::VariantBase >::iterator const *)arg1,SWIG_STD_MOVE(arg2));
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_VariantMap_1Iterator_1getKey(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  std::map< std::string,Glib::VariantBase >::iterator *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,Glib::VariantBase >::iterator **)&jarg1; 
  result = std_map_Sl_std_string_Sc_Glib_VariantBase_Sg__iterator_getKey((std::map< std::string,Glib::VariantBase >::iterator const *)arg1);
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_VariantMap_1Iterator_1getValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,Glib::VariantBase >::iterator *arg1 = 0 ;
  Glib::VariantBase result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,Glib::VariantBase >::iterator **)&jarg1; 
  result = std_map_Sl_std_string_Sc_Glib_VariantBase_Sg__iterator_getValue((std::map< std::string,Glib::VariantBase >::iterator const *)arg1);
  *(Glib::VariantBase **)&jresult = new Glib::VariantBase(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_VariantMap_1Iterator_1setValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::map< std::string,Glib::VariantBase >::iterator *arg1 = 0 ;
  Glib::VariantBase *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< std::string,Glib::VariantBase >::iterator **)&jarg1; 
  arg2 = *(Glib::VariantBase **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Glib::VariantBase const & is null");
    return ;
  } 
  std_map_Sl_std_string_Sc_Glib_VariantBase_Sg__iterator_setValue(arg1,(Glib::VariantBase const &)*arg2);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1VariantMap_1Iterator(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< std::string,Glib::VariantBase >::iterator *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< std::string,Glib::VariantBase >::iterator **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_VariantMap_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::map< std::string,Glib::VariantBase > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,Glib::VariantBase > **)&jarg1; 
  result = (bool)((std::map< std::string,Glib::VariantBase > const *)arg1)->empty();
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_VariantMap_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::map< std::string,Glib::VariantBase > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,Glib::VariantBase > **)&jarg1; 
  (arg1)->clear();
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_VariantMap_1find(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  std::map< std::string,Glib::VariantBase > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::map< std::string,Glib::VariantBase >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,Glib::VariantBase > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  result = (arg1)->find((std::string const &)*arg2);
  *(std::map< std::string,Glib::VariantBase >::iterator **)&jresult = new std::map< std::string,Glib::VariantBase >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_VariantMap_1begin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,Glib::VariantBase > *arg1 = 0 ;
  std::map< std::string,Glib::VariantBase >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,Glib::VariantBase > **)&jarg1; 
  result = (arg1)->begin();
  *(std::map< std::string,Glib::VariantBase >::iterator **)&jresult = new std::map< std::string,Glib::VariantBase >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_VariantMap_1end(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,Glib::VariantBase > *arg1 = 0 ;
  std::map< std::string,Glib::VariantBase >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,Glib::VariantBase > **)&jarg1; 
  result = (arg1)->end();
  *(std::map< std::string,Glib::VariantBase >::iterator **)&jresult = new std::map< std::string,Glib::VariantBase >::iterator(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_VariantMap_1sizeImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::map< std::string,Glib::VariantBase > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,Glib::VariantBase > **)&jarg1; 
  try {
    result = std_map_Sl_std_string_Sc_Glib_VariantBase_Sg__sizeImpl((std::map< std::string,Glib::VariantBase > const *)arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_VariantMap_1containsImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jboolean jresult = 0 ;
  std::map< std::string,Glib::VariantBase > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,Glib::VariantBase > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  result = (bool)std_map_Sl_std_string_Sc_Glib_VariantBase_Sg__containsImpl(arg1,(std::string const &)*arg2);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_VariantMap_1putUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_) {
  std::map< std::string,Glib::VariantBase > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Glib::VariantBase *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::map< std::string,Glib::VariantBase > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = *(Glib::VariantBase **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Glib::VariantBase const & is null");
    return ;
  } 
  std_map_Sl_std_string_Sc_Glib_VariantBase_Sg__putUnchecked(arg1,(std::string const &)*arg2,(Glib::VariantBase const &)*arg3);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_VariantMap_1removeUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::map< std::string,Glib::VariantBase > *arg1 = 0 ;
  std::map< std::string,Glib::VariantBase,std::less< std::string > >::iterator arg2 ;
  std::map< std::string,Glib::VariantBase,std::less< std::string > >::iterator const *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< std::string,Glib::VariantBase > **)&jarg1; 
  argp2 = *(std::map< std::string,Glib::VariantBase,std::less< std::string > >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,Glib::VariantBase,std::less< std::string > >::iterator const");
    return ;
  }
  arg2 = *argp2; 
  std_map_Sl_std_string_Sc_Glib_VariantBase_Sg__removeUnchecked(arg1,SWIG_STD_MOVE(arg2));
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1VariantMap(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< std::string,Glib::VariantBase > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< std::string,Glib::VariantBase > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1QuantityFlagVector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< sigrok::QuantityFlag const * > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (std::vector< sigrok::QuantityFlag const * > *)new std::vector< sigrok::QuantityFlag const * >();
  *(std::vector< sigrok::QuantityFlag const * > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1QuantityFlagVector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< sigrok::QuantityFlag const * > *arg1 = 0 ;
  std::vector< sigrok::QuantityFlag const * > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::QuantityFlag const * > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< sigrok::QuantityFlag const * > const & is null");
    return 0;
  } 
  result = (std::vector< sigrok::QuantityFlag const * > *)new std::vector< sigrok::QuantityFlag const * >((std::vector< sigrok::QuantityFlag const * > const &)*arg1);
  *(std::vector< sigrok::QuantityFlag const * > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlagVector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< sigrok::QuantityFlag const * > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::QuantityFlag const * > **)&jarg1; 
  result = (bool)((std::vector< sigrok::QuantityFlag const * > const *)arg1)->empty();
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlagVector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< sigrok::QuantityFlag const * > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::QuantityFlag const * > **)&jarg1; 
  (arg1)->clear();
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1QuantityFlagVector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  sigrok::QuantityFlag **arg2 = 0 ;
  sigrok::QuantityFlag *temp2 = 0 ;
  std::vector< sigrok::QuantityFlag const * > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  temp2 = *(sigrok::QuantityFlag **)&jarg2;
  arg2 = (sigrok::QuantityFlag **)&temp2; 
  try {
    result = (std::vector< sigrok::QuantityFlag const * > *)new_std_vector_Sl_sigrok_QuantityFlag_SS_const_Sm__Sg___SWIG_2(SWIG_STD_MOVE(arg1),(sigrok::QuantityFlag const *const &)*arg2);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< sigrok::QuantityFlag const * > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlagVector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< sigrok::QuantityFlag const * > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::QuantityFlag const * > **)&jarg1; 
  try {
    result = std_vector_Sl_sigrok_QuantityFlag_SS_const_Sm__Sg__doCapacity(arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlagVector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< sigrok::QuantityFlag const * > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::QuantityFlag const * > **)&jarg1; 
  arg2 = jarg2; 
  try {
    std_vector_Sl_sigrok_QuantityFlag_SS_const_Sm__Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::length_error &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlagVector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< sigrok::QuantityFlag const * > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::QuantityFlag const * > **)&jarg1; 
  try {
    result = std_vector_Sl_sigrok_QuantityFlag_SS_const_Sm__Sg__doSize((std::vector< sigrok::QuantityFlag const * > const *)arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlagVector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< sigrok::QuantityFlag const * > *arg1 = 0 ;
  std::vector< sigrok::QuantityFlag const * >::value_type *arg2 = 0 ;
  std::vector< sigrok::QuantityFlag const * >::value_type temp2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< sigrok::QuantityFlag const * > **)&jarg1; 
  temp2 = *(std::vector< sigrok::QuantityFlag const * >::value_type *)&jarg2;
  arg2 = (std::vector< sigrok::QuantityFlag const * >::value_type *)&temp2; 
  std_vector_Sl_sigrok_QuantityFlag_SS_const_Sm__Sg__doAdd__SWIG_0(arg1,(sigrok::QuantityFlag const *const &)*arg2);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlagVector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< sigrok::QuantityFlag const * > *arg1 = 0 ;
  jint arg2 ;
  std::vector< sigrok::QuantityFlag const * >::value_type *arg3 = 0 ;
  std::vector< sigrok::QuantityFlag const * >::value_type temp3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< sigrok::QuantityFlag const * > **)&jarg1; 
  arg2 = jarg2; 
  temp3 = *(std::vector< sigrok::QuantityFlag const * >::value_type *)&jarg3;
  arg3 = (std::vector< sigrok::QuantityFlag const * >::value_type *)&temp3; 
  try {
    std_vector_Sl_sigrok_QuantityFlag_SS_const_Sm__Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(sigrok::QuantityFlag const *const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlagVector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< sigrok::QuantityFlag const * > *arg1 = 0 ;
  jint arg2 ;
  std::vector< sigrok::QuantityFlag const * >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::QuantityFlag const * > **)&jarg1; 
  arg2 = jarg2; 
  try {
    result = (std::vector< sigrok::QuantityFlag const * >::value_type)std_vector_Sl_sigrok_QuantityFlag_SS_const_Sm__Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< sigrok::QuantityFlag const * >::value_type *)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlagVector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< sigrok::QuantityFlag const * > *arg1 = 0 ;
  jint arg2 ;
  std::vector< sigrok::QuantityFlag const * >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::QuantityFlag const * > **)&jarg1; 
  arg2 = jarg2; 
  try {
    result = (std::vector< sigrok::QuantityFlag const * >::value_type *) &std_vector_Sl_sigrok_QuantityFlag_SS_const_Sm__Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< sigrok::QuantityFlag const * >::value_type *)&jresult = *result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlagVector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< sigrok::QuantityFlag const * > *arg1 = 0 ;
  jint arg2 ;
  std::vector< sigrok::QuantityFlag const * >::value_type *arg3 = 0 ;
  std::vector< sigrok::QuantityFlag const * >::value_type temp3 = 0 ;
  std::vector< sigrok::QuantityFlag const * >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< sigrok::QuantityFlag const * > **)&jarg1; 
  arg2 = jarg2; 
  temp3 = *(std::vector< sigrok::QuantityFlag const * >::value_type *)&jarg3;
  arg3 = (std::vector< sigrok::QuantityFlag const * >::value_type *)&temp3; 
  try {
    result = (std::vector< sigrok::QuantityFlag const * >::value_type)std_vector_Sl_sigrok_QuantityFlag_SS_const_Sm__Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(sigrok::QuantityFlag const *const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< sigrok::QuantityFlag const * >::value_type *)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlagVector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< sigrok::QuantityFlag const * > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< sigrok::QuantityFlag const * > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  try {
    std_vector_Sl_sigrok_QuantityFlag_SS_const_Sm__Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1QuantityFlagVector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< sigrok::QuantityFlag const * > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< sigrok::QuantityFlag const * > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1TriggerStageVector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerStage > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (std::vector< std::shared_ptr< sigrok::TriggerStage > > *)new std::vector< std::shared_ptr< sigrok::TriggerStage > >();
  *(std::vector< std::shared_ptr< sigrok::TriggerStage > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1TriggerStageVector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerStage > > *arg1 = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerStage > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerStage > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::TriggerStage > > const & is null");
    return 0;
  } 
  result = (std::vector< std::shared_ptr< sigrok::TriggerStage > > *)new std::vector< std::shared_ptr< sigrok::TriggerStage > >((std::vector< std::shared_ptr< sigrok::TriggerStage > > const &)*arg1);
  *(std::vector< std::shared_ptr< sigrok::TriggerStage > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerStageVector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerStage > > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerStage > > **)&jarg1; 
  result = (bool)((std::vector< std::shared_ptr< sigrok::TriggerStage > > const *)arg1)->empty();
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerStageVector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< std::shared_ptr< sigrok::TriggerStage > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerStage > > **)&jarg1; 
  (arg1)->clear();
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1TriggerStageVector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2) {
  jlong jresult = 0 ;
  jint arg1 ;
  std::shared_ptr< sigrok::TriggerStage > *arg2 = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerStage > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = jarg1; 
  arg2 = *(std::shared_ptr< sigrok::TriggerStage > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::shared_ptr< sigrok::TriggerStage > const & is null");
    return 0;
  } 
  try {
    result = (std::vector< std::shared_ptr< sigrok::TriggerStage > > *)new_std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerStage_Sg__Sg___SWIG_2(SWIG_STD_MOVE(arg1),(std::shared_ptr< sigrok::TriggerStage > const &)*arg2);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::TriggerStage > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerStageVector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerStage > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerStage > > **)&jarg1; 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerStage_Sg__Sg__doCapacity(arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerStageVector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< std::shared_ptr< sigrok::TriggerStage > > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerStage > > **)&jarg1; 
  arg2 = jarg2; 
  try {
    std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerStage_Sg__Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::length_error &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerStageVector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerStage > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerStage > > **)&jarg1; 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerStage_Sg__Sg__doSize((std::vector< std::shared_ptr< sigrok::TriggerStage > > const *)arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerStageVector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< std::shared_ptr< sigrok::TriggerStage > > *arg1 = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerStage > > **)&jarg1; 
  arg2 = *(std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type const & is null");
    return ;
  } 
  std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerStage_Sg__Sg__doAdd__SWIG_0(arg1,(std::shared_ptr< sigrok::TriggerStage > const &)*arg2);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerStageVector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  std::vector< std::shared_ptr< sigrok::TriggerStage > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerStage > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type const & is null");
    return ;
  } 
  try {
    std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerStage_Sg__Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(std::shared_ptr< sigrok::TriggerStage > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerStageVector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerStage > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerStage > > **)&jarg1; 
  arg2 = jarg2; 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerStage_Sg__Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type **)&jresult = new std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerStageVector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerStage > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerStage > > **)&jarg1; 
  arg2 = jarg2; 
  try {
    result = (std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type *) &std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerStage_Sg__Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerStageVector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerStage > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type *arg3 = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerStage > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type const & is null");
    return 0;
  } 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerStage_Sg__Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(std::shared_ptr< sigrok::TriggerStage > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type **)&jresult = new std::vector< std::shared_ptr< sigrok::TriggerStage > >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerStageVector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< std::shared_ptr< sigrok::TriggerStage > > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerStage > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  try {
    std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerStage_Sg__Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1TriggerStageVector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< std::shared_ptr< sigrok::TriggerStage > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerStage > > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1TriggerMatchVector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerMatch > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (std::vector< std::shared_ptr< sigrok::TriggerMatch > > *)new std::vector< std::shared_ptr< sigrok::TriggerMatch > >();
  *(std::vector< std::shared_ptr< sigrok::TriggerMatch > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1TriggerMatchVector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerMatch > > *arg1 = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerMatch > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerMatch > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::TriggerMatch > > const & is null");
    return 0;
  } 
  result = (std::vector< std::shared_ptr< sigrok::TriggerMatch > > *)new std::vector< std::shared_ptr< sigrok::TriggerMatch > >((std::vector< std::shared_ptr< sigrok::TriggerMatch > > const &)*arg1);
  *(std::vector< std::shared_ptr< sigrok::TriggerMatch > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerMatchVector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerMatch > > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerMatch > > **)&jarg1; 
  result = (bool)((std::vector< std::shared_ptr< sigrok::TriggerMatch > > const *)arg1)->empty();
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerMatchVector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< std::shared_ptr< sigrok::TriggerMatch > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerMatch > > **)&jarg1; 
  (arg1)->clear();
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1TriggerMatchVector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2) {
  jlong jresult = 0 ;
  jint arg1 ;
  std::shared_ptr< sigrok::TriggerMatch > *arg2 = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerMatch > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = jarg1; 
  arg2 = *(std::shared_ptr< sigrok::TriggerMatch > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::shared_ptr< sigrok::TriggerMatch > const & is null");
    return 0;
  } 
  try {
    result = (std::vector< std::shared_ptr< sigrok::TriggerMatch > > *)new_std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerMatch_Sg__Sg___SWIG_2(SWIG_STD_MOVE(arg1),(std::shared_ptr< sigrok::TriggerMatch > const &)*arg2);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::TriggerMatch > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerMatchVector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerMatch > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerMatch > > **)&jarg1; 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerMatch_Sg__Sg__doCapacity(arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerMatchVector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< std::shared_ptr< sigrok::TriggerMatch > > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerMatch > > **)&jarg1; 
  arg2 = jarg2; 
  try {
    std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerMatch_Sg__Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::length_error &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerMatchVector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerMatch > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerMatch > > **)&jarg1; 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerMatch_Sg__Sg__doSize((std::vector< std::shared_ptr< sigrok::TriggerMatch > > const *)arg1);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerMatchVector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< std::shared_ptr< sigrok::TriggerMatch > > *arg1 = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerMatch > > **)&jarg1; 
  arg2 = *(std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type const & is null");
    return ;
  } 
  std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerMatch_Sg__Sg__doAdd__SWIG_0(arg1,(std::shared_ptr< sigrok::TriggerMatch > const &)*arg2);
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerMatchVector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  std::vector< std::shared_ptr< sigrok::TriggerMatch > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerMatch > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type const & is null");
    return ;
  } 
  try {
    std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerMatch_Sg__Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(std::shared_ptr< sigrok::TriggerMatch > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerMatchVector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerMatch > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerMatch > > **)&jarg1; 
  arg2 = jarg2; 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerMatch_Sg__Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type **)&jresult = new std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerMatchVector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerMatch > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerMatch > > **)&jarg1; 
  arg2 = jarg2; 
  try {
    result = (std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type *) &std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerMatch_Sg__Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerMatchVector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  jlong jresult = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerMatch > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type *arg3 = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerMatch > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type const & is null");
    return 0;
  } 
  try {
    result = std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerMatch_Sg__Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(std::shared_ptr< sigrok::TriggerMatch > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return 0;
  }
  *(std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type **)&jresult = new std::vector< std::shared_ptr< sigrok::TriggerMatch > >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerMatchVector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< std::shared_ptr< sigrok::TriggerMatch > > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerMatch > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  try {
    std_vector_Sl_std_shared_ptr_Sl_sigrok_TriggerMatch_Sg__Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
  } catch(std::out_of_range &_e) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
    return ;
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1TriggerMatchVector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< std::shared_ptr< sigrok::TriggerMatch > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< std::shared_ptr< sigrok::TriggerMatch > > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_new_1Error(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  sigrok::Error *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = (sigrok::Error *)new sigrok::Error(arg1);
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(sigrok::Error **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1Error(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::Error *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(sigrok::Error **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_Error_1result_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  sigrok::Error *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(sigrok::Error **)&jarg1; 
  result = (int)(int) ((arg1)->result);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_Error_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  sigrok::Error *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(sigrok::Error **)&jarg1; 
  {
    try {
      result = (char *)((sigrok::Error const *)arg1)->what();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1ResourceReader(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::ResourceReader *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(sigrok::ResourceReader **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Context_1create(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::shared_ptr< sigrok::Context > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = sigrok::Context::create();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Context > **)&jresult = result ? new std::shared_ptr< sigrok::Context >(result) : 0; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_Context_1package_1version(JNIEnv *jenv, jclass jcls) {
  jstring jresult = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = sigrok::Context::package_version();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_Context_1lib_1version(JNIEnv *jenv, jclass jcls) {
  jstring jresult = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = sigrok::Context::lib_version();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jobject JNICALL Java_org_sigrok_core_classes_classesJNI_Context_1drivers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jobject jresult = 0 ;
  sigrok::Context *arg1 = 0 ;
  std::shared_ptr< sigrok::Context > *smartarg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Driver >,std::less< std::string > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Context > **)&jarg1;
  arg1 = (sigrok::Context *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->drivers();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  {
    jclass HashMap = jenv->FindClass("java/util/HashMap");
    jmethodID HashMap_init = jenv->GetMethodID(HashMap, "<init>", "()V");
    jmethodID HashMap_put = jenv->GetMethodID(HashMap, "put",
      "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
    jclass Value = jenv->FindClass("org/sigrok/core/classes/""Driver");
    jmethodID Value_init = jenv->GetMethodID(Value, "<init>", "(JZ)V");
    jresult = jenv->NewObject(HashMap, HashMap_init);
    jlong value = 0;
    for (auto entry : result)
    {
      *(std::shared_ptr< sigrok::Driver > **)&value =
      new std::shared_ptr< sigrok::Driver>(entry.second);
      jenv->CallObjectMethod(jresult, HashMap_put,
        jenv->NewStringUTF(entry.first.c_str()),
        jenv->NewObject(Value, Value_init, value, true));
    }
  }
  return jresult;
}


SWIGEXPORT jobject JNICALL Java_org_sigrok_core_classes_classesJNI_Context_1input_1formats(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jobject jresult = 0 ;
  sigrok::Context *arg1 = 0 ;
  std::shared_ptr< sigrok::Context > *smartarg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::InputFormat >,std::less< std::string > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Context > **)&jarg1;
  arg1 = (sigrok::Context *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->input_formats();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  {
    jclass HashMap = jenv->FindClass("java/util/HashMap");
    jmethodID HashMap_init = jenv->GetMethodID(HashMap, "<init>", "()V");
    jmethodID HashMap_put = jenv->GetMethodID(HashMap, "put",
      "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
    jclass Value = jenv->FindClass("org/sigrok/core/classes/""InputFormat");
    jmethodID Value_init = jenv->GetMethodID(Value, "<init>", "(JZ)V");
    jresult = jenv->NewObject(HashMap, HashMap_init);
    jlong value = 0;
    for (auto entry : result)
    {
      *(std::shared_ptr< sigrok::InputFormat > **)&value =
      new std::shared_ptr< sigrok::InputFormat>(entry.second);
      jenv->CallObjectMethod(jresult, HashMap_put,
        jenv->NewStringUTF(entry.first.c_str()),
        jenv->NewObject(Value, Value_init, value, true));
    }
  }
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Context_1input_1format_1match(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  sigrok::Context *arg1 = 0 ;
  std::string arg2 ;
  std::shared_ptr< sigrok::Context > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::InputFormat > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Context > **)&jarg1;
  arg1 = (sigrok::Context *)(smartarg1 ? smartarg1->get() : 0); 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  (&arg2)->assign(arg2_pstr);
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = (arg1)->input_format_match(SWIG_STD_MOVE(arg2));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::InputFormat > **)&jresult = result ? new std::shared_ptr< sigrok::InputFormat >(result) : 0; 
  return jresult;
}


SWIGEXPORT jobject JNICALL Java_org_sigrok_core_classes_classesJNI_Context_1output_1formats(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jobject jresult = 0 ;
  sigrok::Context *arg1 = 0 ;
  std::shared_ptr< sigrok::Context > *smartarg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::OutputFormat >,std::less< std::string > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Context > **)&jarg1;
  arg1 = (sigrok::Context *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->output_formats();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  {
    jclass HashMap = jenv->FindClass("java/util/HashMap");
    jmethodID HashMap_init = jenv->GetMethodID(HashMap, "<init>", "()V");
    jmethodID HashMap_put = jenv->GetMethodID(HashMap, "put",
      "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
    jclass Value = jenv->FindClass("org/sigrok/core/classes/""OutputFormat");
    jmethodID Value_init = jenv->GetMethodID(Value, "<init>", "(JZ)V");
    jresult = jenv->NewObject(HashMap, HashMap_init);
    jlong value = 0;
    for (auto entry : result)
    {
      *(std::shared_ptr< sigrok::OutputFormat > **)&value =
      new std::shared_ptr< sigrok::OutputFormat>(entry.second);
      jenv->CallObjectMethod(jresult, HashMap_put,
        jenv->NewStringUTF(entry.first.c_str()),
        jenv->NewObject(Value, Value_init, value, true));
    }
  }
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Context_1log_1level(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Context *arg1 = 0 ;
  std::shared_ptr< sigrok::Context const > *smartarg1 = 0 ;
  sigrok::LogLevel *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Context > **)&jarg1;
  arg1 = (sigrok::Context *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (sigrok::LogLevel *)((sigrok::Context const *)arg1)->log_level();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(sigrok::LogLevel **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Context_1set_1log_1level(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  sigrok::Context *arg1 = 0 ;
  sigrok::LogLevel *arg2 = 0 ;
  std::shared_ptr< sigrok::Context > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Context > **)&jarg1;
  arg1 = (sigrok::Context *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = *(sigrok::LogLevel **)&jarg2; 
  {
    try {
      (arg1)->set_log_level((sigrok::LogLevel const *)arg2);
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Context_1set_1log_1callback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  sigrok::Context *arg1 = 0 ;
  SwigValueWrapper< std::function< void (sigrok::LogLevel const *,std::string) > > arg2 ;
  std::shared_ptr< sigrok::Context > *smartarg1 = 0 ;
  sigrok::LogCallbackFunction *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Context > **)&jarg1;
  arg1 = (sigrok::Context *)(smartarg1 ? smartarg1->get() : 0); 
  argp2 = *(sigrok::LogCallbackFunction **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null sigrok::LogCallbackFunction");
    return ;
  }
  arg2 = *argp2; 
  {
    try {
      (arg1)->set_log_callback(SWIG_STD_MOVE(arg2));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Context_1set_1log_1callback_1default(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  sigrok::Context *arg1 = 0 ;
  std::shared_ptr< sigrok::Context > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Context > **)&jarg1;
  arg1 = (sigrok::Context *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (arg1)->set_log_callback_default();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Context_1set_1resource_1reader(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  sigrok::Context *arg1 = 0 ;
  sigrok::ResourceReader *arg2 = 0 ;
  std::shared_ptr< sigrok::Context > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Context > **)&jarg1;
  arg1 = (sigrok::Context *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = *(sigrok::ResourceReader **)&jarg2; 
  {
    try {
      (arg1)->set_resource_reader(arg2);
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Context_1create_1session(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Context *arg1 = 0 ;
  std::shared_ptr< sigrok::Context > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Session > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Context > **)&jarg1;
  arg1 = (sigrok::Context *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->create_session();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Session > **)&jresult = result ? new std::shared_ptr< sigrok::Session >(result) : 0; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Context_1create_1user_1device(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jstring jarg4) {
  jlong jresult = 0 ;
  sigrok::Context *arg1 = 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  std::shared_ptr< sigrok::Context > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::UserDevice > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Context > **)&jarg1;
  arg1 = (sigrok::Context *)(smartarg1 ? smartarg1->get() : 0); 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  (&arg2)->assign(arg2_pstr);
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return 0;
  (&arg3)->assign(arg3_pstr);
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  if(!jarg4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg4_pstr = jenv->GetStringUTFChars(jarg4, 0); 
  if (!arg4_pstr) return 0;
  (&arg4)->assign(arg4_pstr);
  jenv->ReleaseStringUTFChars(jarg4, arg4_pstr); 
  {
    try {
      result = (arg1)->create_user_device(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::UserDevice > **)&jresult = result ? new std::shared_ptr< sigrok::UserDevice >(result) : 0; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Context_1create_1header_1packet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  jlong jresult = 0 ;
  sigrok::Context *arg1 = 0 ;
  Glib::TimeVal arg2 ;
  std::shared_ptr< sigrok::Context > *smartarg1 = 0 ;
  Glib::TimeVal *argp2 ;
  std::shared_ptr< sigrok::Packet > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Context > **)&jarg1;
  arg1 = (sigrok::Context *)(smartarg1 ? smartarg1->get() : 0); 
  argp2 = *(Glib::TimeVal **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null Glib::TimeVal");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (arg1)->create_header_packet(SWIG_STD_MOVE(arg2));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Packet > **)&jresult = result ? new std::shared_ptr< sigrok::Packet >(result) : 0; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Context_1create_1logic_1packet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4) {
  jlong jresult = 0 ;
  sigrok::Context *arg1 = 0 ;
  void *arg2 = 0 ;
  size_t arg3 ;
  unsigned int arg4 ;
  std::shared_ptr< sigrok::Context > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Packet > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Context > **)&jarg1;
  arg1 = (sigrok::Context *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = *(void **)&jarg2; 
  arg3 = (size_t)jarg3; 
  arg4 = (unsigned int)jarg4; 
  {
    try {
      result = (arg1)->create_logic_packet(arg2,SWIG_STD_MOVE(arg3),arg4);
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Packet > **)&jresult = result ? new std::shared_ptr< sigrok::Packet >(result) : 0; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Context_1create_1end_1packet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Context *arg1 = 0 ;
  std::shared_ptr< sigrok::Context > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Packet > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Context > **)&jarg1;
  arg1 = (sigrok::Context *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->create_end_packet();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Packet > **)&jresult = result ? new std::shared_ptr< sigrok::Packet >(result) : 0; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Context_1load_1session(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  sigrok::Context *arg1 = 0 ;
  std::string arg2 ;
  std::shared_ptr< sigrok::Context > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Session > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Context > **)&jarg1;
  arg1 = (sigrok::Context *)(smartarg1 ? smartarg1->get() : 0); 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  (&arg2)->assign(arg2_pstr);
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = (arg1)->load_session(SWIG_STD_MOVE(arg2));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Session > **)&jresult = result ? new std::shared_ptr< sigrok::Session >(result) : 0; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Context_1create_1trigger(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  sigrok::Context *arg1 = 0 ;
  std::string arg2 ;
  std::shared_ptr< sigrok::Context > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Trigger > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Context > **)&jarg1;
  arg1 = (sigrok::Context *)(smartarg1 ? smartarg1->get() : 0); 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  (&arg2)->assign(arg2_pstr);
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = (arg1)->create_trigger(SWIG_STD_MOVE(arg2));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Trigger > **)&jresult = result ? new std::shared_ptr< sigrok::Trigger >(result) : 0; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Context_1open_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  sigrok::Context *arg1 = 0 ;
  std::string arg2 ;
  std::shared_ptr< sigrok::Context > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Input > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Context > **)&jarg1;
  arg1 = (sigrok::Context *)(smartarg1 ? smartarg1->get() : 0); 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  (&arg2)->assign(arg2_pstr);
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = (arg1)->open_file(SWIG_STD_MOVE(arg2));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Input > **)&jresult = result ? new std::shared_ptr< sigrok::Input >(result) : 0; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Context_1open_1stream(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  sigrok::Context *arg1 = 0 ;
  std::string arg2 ;
  std::shared_ptr< sigrok::Context > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Input > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Context > **)&jarg1;
  arg1 = (sigrok::Context *)(smartarg1 ? smartarg1->get() : 0); 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  (&arg2)->assign(arg2_pstr);
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = (arg1)->open_stream(SWIG_STD_MOVE(arg2));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Input > **)&jresult = result ? new std::shared_ptr< sigrok::Input >(result) : 0; 
  return jresult;
}


SWIGEXPORT jobject JNICALL Java_org_sigrok_core_classes_classesJNI_Context_1serials(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jobject jresult = 0 ;
  sigrok::Context *arg1 = 0 ;
  std::shared_ptr< sigrok::Driver > arg2 ;
  std::shared_ptr< sigrok::Context const > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Driver > *argp2 ;
  std::map< std::string,std::string,std::less< std::string > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Context > **)&jarg1;
  arg1 = (sigrok::Context *)(smartarg1 ? smartarg1->get() : 0); 
  argp2 = *(std::shared_ptr< sigrok::Driver > **)&jarg2;
  if (argp2) arg2 = *argp2; 
  {
    try {
      result = ((sigrok::Context const *)arg1)->serials(SWIG_STD_MOVE(arg2));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  {
    jclass HashMap = jenv->FindClass("java/util/HashMap");
    jmethodID init = jenv->GetMethodID(HashMap, "<init>", "()V");
    jmethodID put = jenv->GetMethodID(HashMap, "put",
      "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
    jresult = jenv->NewObject(HashMap, init);
    for (auto entry : result)
    jenv->CallObjectMethod(jresult, put,
      jenv->NewStringUTF(entry.first.c_str()),
      jenv->NewStringUTF(entry.second.c_str()));
  }
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1Context(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::Context *arg1 = 0 ;
  std::shared_ptr< sigrok::Context > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Context > **)&jarg1;
  arg1 = (sigrok::Context *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Context_1add_1log_1callback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlogcallback jarg3) {
  sigrok::Context *arg1 = 0 ;
  JNIEnv *arg2 = 0 ;
  jlogcallback arg3 ;
  std::shared_ptr< sigrok::Context > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  arg2 = jenv;
  
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Context > **)&jarg1;
  arg1 = (sigrok::Context *)(smartarg1 ? smartarg1->get() : 0); 
  arg3 = jarg3; 
  sigrok_Context_add_log_callback(arg1,arg2,SWIG_STD_MOVE(arg3));
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Configurable_1config_1keys(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Configurable *arg1 = 0 ;
  std::shared_ptr< sigrok::Configurable const > *smartarg1 = 0 ;
  std::set< sigrok::ConfigKey const * > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Configurable > **)&jarg1;
  arg1 = (sigrok::Configurable *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::Configurable const *)arg1)->config_keys();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::set< sigrok::ConfigKey const * > **)&jresult = new std::set< sigrok::ConfigKey const * >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Configurable_1config_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  sigrok::Configurable *arg1 = 0 ;
  sigrok::ConfigKey *arg2 = 0 ;
  std::shared_ptr< sigrok::Configurable const > *smartarg1 = 0 ;
  Glib::VariantBase result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Configurable > **)&jarg1;
  arg1 = (sigrok::Configurable *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = *(sigrok::ConfigKey **)&jarg2; 
  {
    try {
      result = ((sigrok::Configurable const *)arg1)->config_get((sigrok::ConfigKey const *)arg2);
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(Glib::VariantBase **)&jresult = new Glib::VariantBase(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Configurable_1config_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
  sigrok::Configurable *arg1 = 0 ;
  sigrok::ConfigKey *arg2 = 0 ;
  Glib::VariantBase *arg3 = 0 ;
  std::shared_ptr< sigrok::Configurable > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Configurable > **)&jarg1;
  arg1 = (sigrok::Configurable *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = *(sigrok::ConfigKey **)&jarg2; 
  arg3 = *(Glib::VariantBase **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Glib::VariantBase const & is null");
    return ;
  } 
  {
    try {
      (arg1)->config_set((sigrok::ConfigKey const *)arg2,(Glib::VariantBase const &)*arg3);
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Configurable_1config_1list(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  sigrok::Configurable *arg1 = 0 ;
  sigrok::ConfigKey *arg2 = 0 ;
  std::shared_ptr< sigrok::Configurable const > *smartarg1 = 0 ;
  Glib::VariantContainerBase result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Configurable > **)&jarg1;
  arg1 = (sigrok::Configurable *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = *(sigrok::ConfigKey **)&jarg2; 
  {
    try {
      result = ((sigrok::Configurable const *)arg1)->config_list((sigrok::ConfigKey const *)arg2);
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(Glib::VariantContainerBase **)&jresult = new Glib::VariantContainerBase(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Configurable_1config_1capabilities(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  sigrok::Configurable *arg1 = 0 ;
  sigrok::ConfigKey *arg2 = 0 ;
  std::shared_ptr< sigrok::Configurable const > *smartarg1 = 0 ;
  std::set< sigrok::Capability const * > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Configurable > **)&jarg1;
  arg1 = (sigrok::Configurable *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = *(sigrok::ConfigKey **)&jarg2; 
  {
    try {
      result = ((sigrok::Configurable const *)arg1)->config_capabilities((sigrok::ConfigKey const *)arg2);
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::set< sigrok::Capability const * > **)&jresult = new std::set< sigrok::Capability const * >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_Configurable_1config_1check(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
  jboolean jresult = 0 ;
  sigrok::Configurable *arg1 = 0 ;
  sigrok::ConfigKey *arg2 = 0 ;
  sigrok::Capability *arg3 = 0 ;
  std::shared_ptr< sigrok::Configurable const > *smartarg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Configurable > **)&jarg1;
  arg1 = (sigrok::Configurable *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = *(sigrok::ConfigKey **)&jarg2; 
  arg3 = *(sigrok::Capability **)&jarg3; 
  {
    try {
      result = (bool)((sigrok::Configurable const *)arg1)->config_check((sigrok::ConfigKey const *)arg2,(sigrok::Capability const *)arg3);
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1Configurable(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::Configurable *arg1 = 0 ;
  std::shared_ptr< sigrok::Configurable > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Configurable > **)&jarg1;
  arg1 = (sigrok::Configurable *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_Driver_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  sigrok::Driver *arg1 = 0 ;
  std::shared_ptr< sigrok::Driver const > *smartarg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Driver > **)&jarg1;
  arg1 = (sigrok::Driver *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::Driver const *)arg1)->name();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_Driver_1long_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  sigrok::Driver *arg1 = 0 ;
  std::shared_ptr< sigrok::Driver const > *smartarg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Driver > **)&jarg1;
  arg1 = (sigrok::Driver *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::Driver const *)arg1)->long_name();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Driver_1scan_1options(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Driver *arg1 = 0 ;
  std::shared_ptr< sigrok::Driver const > *smartarg1 = 0 ;
  std::set< sigrok::ConfigKey const * > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Driver > **)&jarg1;
  arg1 = (sigrok::Driver *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::Driver const *)arg1)->scan_options();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::set< sigrok::ConfigKey const * > **)&jresult = new std::set< sigrok::ConfigKey const * >(result); 
  return jresult;
}


SWIGEXPORT jobject JNICALL Java_org_sigrok_core_classes_classesJNI_Driver_1scan_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jobject jresult = 0 ;
  sigrok::Driver *arg1 = 0 ;
  std::map< sigrok::ConfigKey const *,Glib::VariantBase,std::less< sigrok::ConfigKey const * > > arg2 ;
  std::shared_ptr< sigrok::Driver > *smartarg1 = 0 ;
  std::map< sigrok::ConfigKey const *,Glib::VariantBase,std::less< sigrok::ConfigKey const * > > *argp2 ;
  std::vector< std::shared_ptr< sigrok::HardwareDevice > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Driver > **)&jarg1;
  arg1 = (sigrok::Driver *)(smartarg1 ? smartarg1->get() : 0); 
  argp2 = *(std::map< sigrok::ConfigKey const *,Glib::VariantBase,std::less< sigrok::ConfigKey const * > > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< sigrok::ConfigKey const *,Glib::VariantBase,std::less< sigrok::ConfigKey const * > >");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (arg1)->scan(SWIG_STD_MOVE(arg2));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  {
    jclass Vector = jenv->FindClass("java/util/Vector");
    jmethodID Vector_init = jenv->GetMethodID(Vector, "<init>", "()V");
    jmethodID Vector_add = jenv->GetMethodID(Vector, "add",
      "(Ljava/lang/Object;)Z");
    jclass Value = jenv->FindClass("org/sigrok/core/classes/""HardwareDevice");
    jmethodID Value_init = jenv->GetMethodID(Value, "<init>", "(JZ)V");
    jresult = jenv->NewObject(Vector, Vector_init);
    jlong value = 0;
    for (auto entry : result)
    {
      *(std::shared_ptr<sigrok::HardwareDevice> **) &value = new std::shared_ptr<sigrok::HardwareDevice>(entry);
      jenv->CallBooleanMethod(jresult, Vector_add,
        jenv->NewObject(Value, Value_init, value, true));
    }
  }
  return jresult;
}


SWIGEXPORT jobject JNICALL Java_org_sigrok_core_classes_classesJNI_Driver_1scan_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jobject jresult = 0 ;
  sigrok::Driver *arg1 = 0 ;
  std::shared_ptr< sigrok::Driver > *smartarg1 = 0 ;
  std::vector< std::shared_ptr< sigrok::HardwareDevice > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Driver > **)&jarg1;
  arg1 = (sigrok::Driver *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->scan();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  {
    jclass Vector = jenv->FindClass("java/util/Vector");
    jmethodID Vector_init = jenv->GetMethodID(Vector, "<init>", "()V");
    jmethodID Vector_add = jenv->GetMethodID(Vector, "add",
      "(Ljava/lang/Object;)Z");
    jclass Value = jenv->FindClass("org/sigrok/core/classes/""HardwareDevice");
    jmethodID Value_init = jenv->GetMethodID(Value, "<init>", "(JZ)V");
    jresult = jenv->NewObject(Vector, Vector_init);
    jlong value = 0;
    for (auto entry : result)
    {
      *(std::shared_ptr<sigrok::HardwareDevice> **) &value = new std::shared_ptr<sigrok::HardwareDevice>(entry);
      jenv->CallBooleanMethod(jresult, Vector_add,
        jenv->NewObject(Value, Value_init, value, true));
    }
  }
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1Driver(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::Driver *arg1 = 0 ;
  std::shared_ptr< sigrok::Driver > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Driver > **)&jarg1;
  arg1 = (sigrok::Driver *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_Device_1vendor(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  sigrok::Device *arg1 = 0 ;
  std::shared_ptr< sigrok::Device const > *smartarg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Device > **)&jarg1;
  arg1 = (sigrok::Device *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::Device const *)arg1)->vendor();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_Device_1model(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  sigrok::Device *arg1 = 0 ;
  std::shared_ptr< sigrok::Device const > *smartarg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Device > **)&jarg1;
  arg1 = (sigrok::Device *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::Device const *)arg1)->model();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_Device_1version(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  sigrok::Device *arg1 = 0 ;
  std::shared_ptr< sigrok::Device const > *smartarg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Device > **)&jarg1;
  arg1 = (sigrok::Device *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::Device const *)arg1)->version();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_Device_1serial_1number(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  sigrok::Device *arg1 = 0 ;
  std::shared_ptr< sigrok::Device const > *smartarg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Device > **)&jarg1;
  arg1 = (sigrok::Device *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::Device const *)arg1)->serial_number();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_Device_1connection_1id(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  sigrok::Device *arg1 = 0 ;
  std::shared_ptr< sigrok::Device const > *smartarg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Device > **)&jarg1;
  arg1 = (sigrok::Device *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::Device const *)arg1)->connection_id();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jobject JNICALL Java_org_sigrok_core_classes_classesJNI_Device_1channels(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jobject jresult = 0 ;
  sigrok::Device *arg1 = 0 ;
  std::shared_ptr< sigrok::Device > *smartarg1 = 0 ;
  std::vector< std::shared_ptr< sigrok::Channel > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Device > **)&jarg1;
  arg1 = (sigrok::Device *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->channels();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  {
    jclass Vector = jenv->FindClass("java/util/Vector");
    jmethodID Vector_init = jenv->GetMethodID(Vector, "<init>", "()V");
    jmethodID Vector_add = jenv->GetMethodID(Vector, "add",
      "(Ljava/lang/Object;)Z");
    jclass Value = jenv->FindClass("org/sigrok/core/classes/""Channel");
    jmethodID Value_init = jenv->GetMethodID(Value, "<init>", "(JZ)V");
    jresult = jenv->NewObject(Vector, Vector_init);
    jlong value = 0;
    for (auto entry : result)
    {
      *(std::shared_ptr<sigrok::Channel> **) &value = new std::shared_ptr<sigrok::Channel>(entry);
      jenv->CallBooleanMethod(jresult, Vector_add,
        jenv->NewObject(Value, Value_init, value, true));
    }
  }
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Device_1channel_1groups(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Device *arg1 = 0 ;
  std::shared_ptr< sigrok::Device > *smartarg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::ChannelGroup >,std::less< std::string > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Device > **)&jarg1;
  arg1 = (sigrok::Device *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->channel_groups();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::map< std::string,std::shared_ptr< sigrok::ChannelGroup >,std::less< std::string > > **)&jresult = new std::map< std::string,std::shared_ptr< sigrok::ChannelGroup >,std::less< std::string > >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Device_1open(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  sigrok::Device *arg1 = 0 ;
  std::shared_ptr< sigrok::Device > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Device > **)&jarg1;
  arg1 = (sigrok::Device *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (arg1)->open();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Device_1close(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  sigrok::Device *arg1 = 0 ;
  std::shared_ptr< sigrok::Device > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Device > **)&jarg1;
  arg1 = (sigrok::Device *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (arg1)->close();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1Device(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::Device *arg1 = 0 ;
  std::shared_ptr< sigrok::Device > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Device > **)&jarg1;
  arg1 = (sigrok::Device *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_HardwareDevice_1driver(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::HardwareDevice *arg1 = 0 ;
  std::shared_ptr< sigrok::HardwareDevice > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Driver > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::HardwareDevice > **)&jarg1;
  arg1 = (sigrok::HardwareDevice *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->driver();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Driver > **)&jresult = result ? new std::shared_ptr< sigrok::Driver >(result) : 0; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1HardwareDevice(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::HardwareDevice *arg1 = 0 ;
  std::shared_ptr< sigrok::HardwareDevice > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::HardwareDevice > **)&jarg1;
  arg1 = (sigrok::HardwareDevice *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_UserDevice_1add_1channel(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jobject jarg3_, jstring jarg4) {
  jlong jresult = 0 ;
  sigrok::UserDevice *arg1 = 0 ;
  unsigned int arg2 ;
  sigrok::ChannelType *arg3 = 0 ;
  std::string arg4 ;
  std::shared_ptr< sigrok::UserDevice > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Channel > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::UserDevice > **)&jarg1;
  arg1 = (sigrok::UserDevice *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (unsigned int)jarg2; 
  arg3 = *(sigrok::ChannelType **)&jarg3; 
  if(!jarg4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg4_pstr = jenv->GetStringUTFChars(jarg4, 0); 
  if (!arg4_pstr) return 0;
  (&arg4)->assign(arg4_pstr);
  jenv->ReleaseStringUTFChars(jarg4, arg4_pstr); 
  {
    try {
      result = (arg1)->add_channel(arg2,(sigrok::ChannelType const *)arg3,SWIG_STD_MOVE(arg4));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Channel > **)&jresult = result ? new std::shared_ptr< sigrok::Channel >(result) : 0; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1UserDevice(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::UserDevice *arg1 = 0 ;
  std::shared_ptr< sigrok::UserDevice > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::UserDevice > **)&jarg1;
  arg1 = (sigrok::UserDevice *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_Channel_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  sigrok::Channel *arg1 = 0 ;
  std::shared_ptr< sigrok::Channel const > *smartarg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Channel > **)&jarg1;
  arg1 = (sigrok::Channel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::Channel const *)arg1)->name();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Channel_1set_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  sigrok::Channel *arg1 = 0 ;
  std::string arg2 ;
  std::shared_ptr< sigrok::Channel > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Channel > **)&jarg1;
  arg1 = (sigrok::Channel *)(smartarg1 ? smartarg1->get() : 0); 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  } 
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  (&arg2)->assign(arg2_pstr);
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      (arg1)->set_name(SWIG_STD_MOVE(arg2));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Channel_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Channel *arg1 = 0 ;
  std::shared_ptr< sigrok::Channel const > *smartarg1 = 0 ;
  sigrok::ChannelType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Channel > **)&jarg1;
  arg1 = (sigrok::Channel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (sigrok::ChannelType *)((sigrok::Channel const *)arg1)->type();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(sigrok::ChannelType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_Channel_1enabled(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  sigrok::Channel *arg1 = 0 ;
  std::shared_ptr< sigrok::Channel const > *smartarg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Channel > **)&jarg1;
  arg1 = (sigrok::Channel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((sigrok::Channel const *)arg1)->enabled();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Channel_1set_1enabled(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  sigrok::Channel *arg1 = 0 ;
  bool arg2 ;
  std::shared_ptr< sigrok::Channel > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Channel > **)&jarg1;
  arg1 = (sigrok::Channel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? true : false; 
  {
    try {
      (arg1)->set_enabled(arg2);
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Channel_1index(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Channel *arg1 = 0 ;
  std::shared_ptr< sigrok::Channel const > *smartarg1 = 0 ;
  unsigned int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Channel > **)&jarg1;
  arg1 = (sigrok::Channel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (unsigned int)((sigrok::Channel const *)arg1)->index();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1Channel(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::Channel *arg1 = 0 ;
  std::shared_ptr< sigrok::Channel > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Channel > **)&jarg1;
  arg1 = (sigrok::Channel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelGroup_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  sigrok::ChannelGroup *arg1 = 0 ;
  std::shared_ptr< sigrok::ChannelGroup const > *smartarg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::ChannelGroup > **)&jarg1;
  arg1 = (sigrok::ChannelGroup *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::ChannelGroup const *)arg1)->name();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jobject JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelGroup_1channels(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jobject jresult = 0 ;
  sigrok::ChannelGroup *arg1 = 0 ;
  std::shared_ptr< sigrok::ChannelGroup > *smartarg1 = 0 ;
  std::vector< std::shared_ptr< sigrok::Channel > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::ChannelGroup > **)&jarg1;
  arg1 = (sigrok::ChannelGroup *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->channels();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  {
    jclass Vector = jenv->FindClass("java/util/Vector");
    jmethodID Vector_init = jenv->GetMethodID(Vector, "<init>", "()V");
    jmethodID Vector_add = jenv->GetMethodID(Vector, "add",
      "(Ljava/lang/Object;)Z");
    jclass Value = jenv->FindClass("org/sigrok/core/classes/""Channel");
    jmethodID Value_init = jenv->GetMethodID(Value, "<init>", "(JZ)V");
    jresult = jenv->NewObject(Vector, Vector_init);
    jlong value = 0;
    for (auto entry : result)
    {
      *(std::shared_ptr<sigrok::Channel> **) &value = new std::shared_ptr<sigrok::Channel>(entry);
      jenv->CallBooleanMethod(jresult, Vector_add,
        jenv->NewObject(Value, Value_init, value, true));
    }
  }
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1ChannelGroup(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::ChannelGroup *arg1 = 0 ;
  std::shared_ptr< sigrok::ChannelGroup > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::ChannelGroup > **)&jarg1;
  arg1 = (sigrok::ChannelGroup *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_Trigger_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  sigrok::Trigger *arg1 = 0 ;
  std::shared_ptr< sigrok::Trigger const > *smartarg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Trigger > **)&jarg1;
  arg1 = (sigrok::Trigger *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::Trigger const *)arg1)->name();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Trigger_1stages(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Trigger *arg1 = 0 ;
  std::shared_ptr< sigrok::Trigger > *smartarg1 = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerStage > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Trigger > **)&jarg1;
  arg1 = (sigrok::Trigger *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->stages();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::vector< std::shared_ptr< sigrok::TriggerStage > > **)&jresult = new std::vector< std::shared_ptr< sigrok::TriggerStage > >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Trigger_1add_1stage(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Trigger *arg1 = 0 ;
  std::shared_ptr< sigrok::Trigger > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::TriggerStage > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Trigger > **)&jarg1;
  arg1 = (sigrok::Trigger *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->add_stage();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::TriggerStage > **)&jresult = result ? new std::shared_ptr< sigrok::TriggerStage >(result) : 0; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1Trigger(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::Trigger *arg1 = 0 ;
  std::shared_ptr< sigrok::Trigger > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Trigger > **)&jarg1;
  arg1 = (sigrok::Trigger *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerStage_1number(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  sigrok::TriggerStage *arg1 = 0 ;
  std::shared_ptr< sigrok::TriggerStage const > *smartarg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::TriggerStage > **)&jarg1;
  arg1 = (sigrok::TriggerStage *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (int)((sigrok::TriggerStage const *)arg1)->number();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerStage_1matches(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::TriggerStage *arg1 = 0 ;
  std::shared_ptr< sigrok::TriggerStage > *smartarg1 = 0 ;
  std::vector< std::shared_ptr< sigrok::TriggerMatch > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::TriggerStage > **)&jarg1;
  arg1 = (sigrok::TriggerStage *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->matches();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::vector< std::shared_ptr< sigrok::TriggerMatch > > **)&jresult = new std::vector< std::shared_ptr< sigrok::TriggerMatch > >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerStage_1add_1match_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
  sigrok::TriggerStage *arg1 = 0 ;
  std::shared_ptr< sigrok::Channel > arg2 ;
  sigrok::TriggerMatchType *arg3 = 0 ;
  std::shared_ptr< sigrok::TriggerStage > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Channel > *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::TriggerStage > **)&jarg1;
  arg1 = (sigrok::TriggerStage *)(smartarg1 ? smartarg1->get() : 0); 
  argp2 = *(std::shared_ptr< sigrok::Channel > **)&jarg2;
  if (argp2) arg2 = *argp2; 
  arg3 = *(sigrok::TriggerMatchType **)&jarg3; 
  {
    try {
      (arg1)->add_match(SWIG_STD_MOVE(arg2),(sigrok::TriggerMatchType const *)arg3);
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerStage_1add_1match_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jfloat jarg4) {
  sigrok::TriggerStage *arg1 = 0 ;
  std::shared_ptr< sigrok::Channel > arg2 ;
  sigrok::TriggerMatchType *arg3 = 0 ;
  float arg4 ;
  std::shared_ptr< sigrok::TriggerStage > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Channel > *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::TriggerStage > **)&jarg1;
  arg1 = (sigrok::TriggerStage *)(smartarg1 ? smartarg1->get() : 0); 
  argp2 = *(std::shared_ptr< sigrok::Channel > **)&jarg2;
  if (argp2) arg2 = *argp2; 
  arg3 = *(sigrok::TriggerMatchType **)&jarg3; 
  arg4 = (float)jarg4; 
  {
    try {
      (arg1)->add_match(SWIG_STD_MOVE(arg2),(sigrok::TriggerMatchType const *)arg3,arg4);
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1TriggerStage(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::TriggerStage *arg1 = 0 ;
  std::shared_ptr< sigrok::TriggerStage > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::TriggerStage > **)&jarg1;
  arg1 = (sigrok::TriggerStage *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerMatch_1channel(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::TriggerMatch *arg1 = 0 ;
  std::shared_ptr< sigrok::TriggerMatch > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Channel > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::TriggerMatch > **)&jarg1;
  arg1 = (sigrok::TriggerMatch *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->channel();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Channel > **)&jresult = result ? new std::shared_ptr< sigrok::Channel >(result) : 0; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerMatch_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::TriggerMatch *arg1 = 0 ;
  std::shared_ptr< sigrok::TriggerMatch const > *smartarg1 = 0 ;
  sigrok::TriggerMatchType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::TriggerMatch > **)&jarg1;
  arg1 = (sigrok::TriggerMatch *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (sigrok::TriggerMatchType *)((sigrok::TriggerMatch const *)arg1)->type();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(sigrok::TriggerMatchType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jfloat JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerMatch_1value(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jfloat jresult = 0 ;
  sigrok::TriggerMatch *arg1 = 0 ;
  std::shared_ptr< sigrok::TriggerMatch const > *smartarg1 = 0 ;
  float result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::TriggerMatch > **)&jarg1;
  arg1 = (sigrok::TriggerMatch *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (float)((sigrok::TriggerMatch const *)arg1)->value();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = (jfloat)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1TriggerMatch(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::TriggerMatch *arg1 = 0 ;
  std::shared_ptr< sigrok::TriggerMatch > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::TriggerMatch > **)&jarg1;
  arg1 = (sigrok::TriggerMatch *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1SessionDevice(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::SessionDevice *arg1 = 0 ;
  std::shared_ptr< sigrok::SessionDevice > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::SessionDevice > **)&jarg1;
  arg1 = (sigrok::SessionDevice *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Session_1add_1device(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  sigrok::Session *arg1 = 0 ;
  std::shared_ptr< sigrok::Device > arg2 ;
  std::shared_ptr< sigrok::Session > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Device > *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Session > **)&jarg1;
  arg1 = (sigrok::Session *)(smartarg1 ? smartarg1->get() : 0); 
  argp2 = *(std::shared_ptr< sigrok::Device > **)&jarg2;
  if (argp2) arg2 = *argp2; 
  {
    try {
      (arg1)->add_device(SWIG_STD_MOVE(arg2));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Session_1devices(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Session *arg1 = 0 ;
  std::shared_ptr< sigrok::Session > *smartarg1 = 0 ;
  std::vector< std::shared_ptr< sigrok::Device > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Session > **)&jarg1;
  arg1 = (sigrok::Session *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->devices();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::vector< std::shared_ptr< sigrok::Device > > **)&jresult = new std::vector< std::shared_ptr< sigrok::Device > >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Session_1remove_1devices(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  sigrok::Session *arg1 = 0 ;
  std::shared_ptr< sigrok::Session > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Session > **)&jarg1;
  arg1 = (sigrok::Session *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (arg1)->remove_devices();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Session_1add_1datafeed_1callback_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  sigrok::Session *arg1 = 0 ;
  SwigValueWrapper< std::function< void (std::shared_ptr< sigrok::Device >,std::shared_ptr< sigrok::Packet >) > > arg2 ;
  std::shared_ptr< sigrok::Session > *smartarg1 = 0 ;
  sigrok::DatafeedCallbackFunction *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Session > **)&jarg1;
  arg1 = (sigrok::Session *)(smartarg1 ? smartarg1->get() : 0); 
  argp2 = *(sigrok::DatafeedCallbackFunction **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null sigrok::DatafeedCallbackFunction");
    return ;
  }
  arg2 = *argp2; 
  {
    try {
      (arg1)->add_datafeed_callback(SWIG_STD_MOVE(arg2));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Session_1remove_1datafeed_1callbacks(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  sigrok::Session *arg1 = 0 ;
  std::shared_ptr< sigrok::Session > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Session > **)&jarg1;
  arg1 = (sigrok::Session *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (arg1)->remove_datafeed_callbacks();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Session_1start(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  sigrok::Session *arg1 = 0 ;
  std::shared_ptr< sigrok::Session > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Session > **)&jarg1;
  arg1 = (sigrok::Session *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (arg1)->start();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Session_1run(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  sigrok::Session *arg1 = 0 ;
  std::shared_ptr< sigrok::Session > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Session > **)&jarg1;
  arg1 = (sigrok::Session *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (arg1)->run();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Session_1stop(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  sigrok::Session *arg1 = 0 ;
  std::shared_ptr< sigrok::Session > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Session > **)&jarg1;
  arg1 = (sigrok::Session *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (arg1)->stop();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_Session_1is_1running(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  sigrok::Session *arg1 = 0 ;
  std::shared_ptr< sigrok::Session const > *smartarg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Session > **)&jarg1;
  arg1 = (sigrok::Session *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((sigrok::Session const *)arg1)->is_running();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Session_1set_1stopped_1callback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  sigrok::Session *arg1 = 0 ;
  sigrok::SessionStoppedCallback arg2 ;
  std::shared_ptr< sigrok::Session > *smartarg1 = 0 ;
  sigrok::SessionStoppedCallback *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Session > **)&jarg1;
  arg1 = (sigrok::Session *)(smartarg1 ? smartarg1->get() : 0); 
  argp2 = *(sigrok::SessionStoppedCallback **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null sigrok::SessionStoppedCallback");
    return ;
  }
  arg2 = *argp2; 
  {
    try {
      (arg1)->set_stopped_callback(SWIG_STD_MOVE(arg2));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Session_1trigger(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Session *arg1 = 0 ;
  std::shared_ptr< sigrok::Session > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Trigger > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Session > **)&jarg1;
  arg1 = (sigrok::Session *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->trigger();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Trigger > **)&jresult = result ? new std::shared_ptr< sigrok::Trigger >(result) : 0; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Session_1context(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Session *arg1 = 0 ;
  std::shared_ptr< sigrok::Session > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Context > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Session > **)&jarg1;
  arg1 = (sigrok::Session *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->context();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Context > **)&jresult = result ? new std::shared_ptr< sigrok::Context >(result) : 0; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Session_1set_1trigger(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  sigrok::Session *arg1 = 0 ;
  std::shared_ptr< sigrok::Trigger > arg2 ;
  std::shared_ptr< sigrok::Session > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Trigger > *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Session > **)&jarg1;
  arg1 = (sigrok::Session *)(smartarg1 ? smartarg1->get() : 0); 
  argp2 = *(std::shared_ptr< sigrok::Trigger > **)&jarg2;
  if (argp2) arg2 = *argp2; 
  {
    try {
      (arg1)->set_trigger(SWIG_STD_MOVE(arg2));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_Session_1filename(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  sigrok::Session *arg1 = 0 ;
  std::shared_ptr< sigrok::Session const > *smartarg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Session > **)&jarg1;
  arg1 = (sigrok::Session *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::Session const *)arg1)->filename();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1Session(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::Session *arg1 = 0 ;
  std::shared_ptr< sigrok::Session > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Session > **)&jarg1;
  arg1 = (sigrok::Session *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Session_1add_1datafeed_1callback_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdatafeedcallback jarg3) {
  sigrok::Session *arg1 = 0 ;
  JNIEnv *arg2 = 0 ;
  jdatafeedcallback arg3 ;
  std::shared_ptr< sigrok::Session > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  arg2 = jenv;
  
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Session > **)&jarg1;
  arg1 = (sigrok::Session *)(smartarg1 ? smartarg1->get() : 0); 
  arg3 = jarg3; 
  sigrok_Session_add_datafeed_callback__SWIG_1(arg1,arg2,SWIG_STD_MOVE(arg3));
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Packet_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Packet *arg1 = 0 ;
  std::shared_ptr< sigrok::Packet const > *smartarg1 = 0 ;
  sigrok::PacketType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Packet > **)&jarg1;
  arg1 = (sigrok::Packet *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (sigrok::PacketType *)((sigrok::Packet const *)arg1)->type();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(sigrok::PacketType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Packet_1payload(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Packet *arg1 = 0 ;
  std::shared_ptr< sigrok::Packet > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::PacketPayload > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Packet > **)&jarg1;
  arg1 = (sigrok::Packet *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->payload();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::PacketPayload > **)&jresult = result ? new std::shared_ptr< sigrok::PacketPayload >(result) : 0; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1Packet(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::Packet *arg1 = 0 ;
  std::shared_ptr< sigrok::Packet > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Packet > **)&jarg1;
  arg1 = (sigrok::Packet *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1PacketPayload(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::PacketPayload *arg1 = 0 ;
  std::shared_ptr< sigrok::PacketPayload > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::PacketPayload > **)&jarg1;
  arg1 = (sigrok::PacketPayload *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_Header_1feed_1version(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  sigrok::Header *arg1 = 0 ;
  std::shared_ptr< sigrok::Header const > *smartarg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Header > **)&jarg1;
  arg1 = (sigrok::Header *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (int)((sigrok::Header const *)arg1)->feed_version();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Header_1start_1time(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Header *arg1 = 0 ;
  std::shared_ptr< sigrok::Header const > *smartarg1 = 0 ;
  Glib::TimeVal result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Header > **)&jarg1;
  arg1 = (sigrok::Header *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::Header const *)arg1)->start_time();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(Glib::TimeVal **)&jresult = new Glib::TimeVal(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1Header(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::Header *arg1 = 0 ;
  std::shared_ptr< sigrok::Header > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Header > **)&jarg1;
  arg1 = (sigrok::Header *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1Meta(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::Meta *arg1 = 0 ;
  std::shared_ptr< sigrok::Meta > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Meta > **)&jarg1;
  arg1 = (sigrok::Meta *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Logic_1data_1pointer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Logic *arg1 = 0 ;
  std::shared_ptr< sigrok::Logic > *smartarg1 = 0 ;
  void *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Logic > **)&jarg1;
  arg1 = (sigrok::Logic *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (void *)(arg1)->data_pointer();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(void **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Logic_1data_1length(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Logic *arg1 = 0 ;
  std::shared_ptr< sigrok::Logic const > *smartarg1 = 0 ;
  size_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Logic > **)&jarg1;
  arg1 = (sigrok::Logic *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::Logic const *)arg1)->data_length();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Logic_1unit_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Logic *arg1 = 0 ;
  std::shared_ptr< sigrok::Logic const > *smartarg1 = 0 ;
  unsigned int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Logic > **)&jarg1;
  arg1 = (sigrok::Logic *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (unsigned int)((sigrok::Logic const *)arg1)->unit_size();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1Logic(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::Logic *arg1 = 0 ;
  std::shared_ptr< sigrok::Logic > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Logic > **)&jarg1;
  arg1 = (sigrok::Logic *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Analog_1data_1pointer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Analog *arg1 = 0 ;
  std::shared_ptr< sigrok::Analog > *smartarg1 = 0 ;
  void *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Analog > **)&jarg1;
  arg1 = (sigrok::Analog *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (void *)(arg1)->data_pointer();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(void **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Analog_1get_1data_1as_1float(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  sigrok::Analog *arg1 = 0 ;
  float *arg2 = 0 ;
  std::shared_ptr< sigrok::Analog > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Analog > **)&jarg1;
  arg1 = (sigrok::Analog *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = *(float **)&jarg2; 
  {
    try {
      (arg1)->get_data_as_float(arg2);
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Analog_1num_1samples(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Analog *arg1 = 0 ;
  std::shared_ptr< sigrok::Analog const > *smartarg1 = 0 ;
  unsigned int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Analog > **)&jarg1;
  arg1 = (sigrok::Analog *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (unsigned int)((sigrok::Analog const *)arg1)->num_samples();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jobject JNICALL Java_org_sigrok_core_classes_classesJNI_Analog_1channels(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jobject jresult = 0 ;
  sigrok::Analog *arg1 = 0 ;
  std::shared_ptr< sigrok::Analog > *smartarg1 = 0 ;
  std::vector< std::shared_ptr< sigrok::Channel > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Analog > **)&jarg1;
  arg1 = (sigrok::Analog *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->channels();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  {
    jclass Vector = jenv->FindClass("java/util/Vector");
    jmethodID Vector_init = jenv->GetMethodID(Vector, "<init>", "()V");
    jmethodID Vector_add = jenv->GetMethodID(Vector, "add",
      "(Ljava/lang/Object;)Z");
    jclass Value = jenv->FindClass("org/sigrok/core/classes/""Channel");
    jmethodID Value_init = jenv->GetMethodID(Value, "<init>", "(JZ)V");
    jresult = jenv->NewObject(Vector, Vector_init);
    jlong value = 0;
    for (auto entry : result)
    {
      *(std::shared_ptr<sigrok::Channel> **) &value = new std::shared_ptr<sigrok::Channel>(entry);
      jenv->CallBooleanMethod(jresult, Vector_add,
        jenv->NewObject(Value, Value_init, value, true));
    }
  }
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Analog_1unitsize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Analog *arg1 = 0 ;
  std::shared_ptr< sigrok::Analog const > *smartarg1 = 0 ;
  unsigned int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Analog > **)&jarg1;
  arg1 = (sigrok::Analog *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (unsigned int)((sigrok::Analog const *)arg1)->unitsize();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_Analog_1is_1signed(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  sigrok::Analog *arg1 = 0 ;
  std::shared_ptr< sigrok::Analog const > *smartarg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Analog > **)&jarg1;
  arg1 = (sigrok::Analog *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((sigrok::Analog const *)arg1)->is_signed();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_Analog_1is_1float(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  sigrok::Analog *arg1 = 0 ;
  std::shared_ptr< sigrok::Analog const > *smartarg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Analog > **)&jarg1;
  arg1 = (sigrok::Analog *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((sigrok::Analog const *)arg1)->is_float();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_Analog_1is_1bigendian(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  sigrok::Analog *arg1 = 0 ;
  std::shared_ptr< sigrok::Analog const > *smartarg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Analog > **)&jarg1;
  arg1 = (sigrok::Analog *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((sigrok::Analog const *)arg1)->is_bigendian();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_sigrok_core_classes_classesJNI_Analog_1digits(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  sigrok::Analog *arg1 = 0 ;
  std::shared_ptr< sigrok::Analog const > *smartarg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Analog > **)&jarg1;
  arg1 = (sigrok::Analog *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (int)((sigrok::Analog const *)arg1)->digits();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_Analog_1is_1digits_1decimal(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  sigrok::Analog *arg1 = 0 ;
  std::shared_ptr< sigrok::Analog const > *smartarg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Analog > **)&jarg1;
  arg1 = (sigrok::Analog *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((sigrok::Analog const *)arg1)->is_digits_decimal();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Analog_1scale(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Analog *arg1 = 0 ;
  std::shared_ptr< sigrok::Analog > *smartarg1 = 0 ;
  SwigValueWrapper< std::shared_ptr< sigrok::Rational > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Analog > **)&jarg1;
  arg1 = (sigrok::Analog *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->scale();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Rational > **)&jresult = new std::shared_ptr< sigrok::Rational >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Analog_1offset(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Analog *arg1 = 0 ;
  std::shared_ptr< sigrok::Analog > *smartarg1 = 0 ;
  SwigValueWrapper< std::shared_ptr< sigrok::Rational > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Analog > **)&jarg1;
  arg1 = (sigrok::Analog *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->offset();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Rational > **)&jresult = new std::shared_ptr< sigrok::Rational >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Analog_1mq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Analog *arg1 = 0 ;
  std::shared_ptr< sigrok::Analog const > *smartarg1 = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Analog > **)&jarg1;
  arg1 = (sigrok::Analog *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (sigrok::Quantity *)((sigrok::Analog const *)arg1)->mq();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Analog_1unit(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Analog *arg1 = 0 ;
  std::shared_ptr< sigrok::Analog const > *smartarg1 = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Analog > **)&jarg1;
  arg1 = (sigrok::Analog *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (sigrok::Unit *)((sigrok::Analog const *)arg1)->unit();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Analog_1mq_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Analog *arg1 = 0 ;
  std::shared_ptr< sigrok::Analog const > *smartarg1 = 0 ;
  std::vector< sigrok::QuantityFlag const * > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Analog > **)&jarg1;
  arg1 = (sigrok::Analog *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::Analog const *)arg1)->mq_flags();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::vector< sigrok::QuantityFlag const * > **)&jresult = new std::vector< sigrok::QuantityFlag const * >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Analog_1get_1logic_1via_1threshold_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jlong jarg3) {
  jlong jresult = 0 ;
  sigrok::Analog *arg1 = 0 ;
  float arg2 ;
  uint8_t *arg3 = 0 ;
  std::shared_ptr< sigrok::Analog const > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Logic > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Analog > **)&jarg1;
  arg1 = (sigrok::Analog *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (float)jarg2; 
  arg3 = *(uint8_t **)&jarg3; 
  {
    try {
      result = ((sigrok::Analog const *)arg1)->get_logic_via_threshold(arg2,arg3);
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Logic > **)&jresult = result ? new std::shared_ptr< sigrok::Logic >(result) : 0; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Analog_1get_1logic_1via_1threshold_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) {
  jlong jresult = 0 ;
  sigrok::Analog *arg1 = 0 ;
  float arg2 ;
  std::shared_ptr< sigrok::Analog const > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Logic > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Analog > **)&jarg1;
  arg1 = (sigrok::Analog *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (float)jarg2; 
  {
    try {
      result = ((sigrok::Analog const *)arg1)->get_logic_via_threshold(arg2);
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Logic > **)&jresult = result ? new std::shared_ptr< sigrok::Logic >(result) : 0; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Analog_1get_1logic_1via_1schmitt_1trigger_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3, jlong jarg4, jlong jarg5) {
  jlong jresult = 0 ;
  sigrok::Analog *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  uint8_t *arg4 = 0 ;
  uint8_t *arg5 = 0 ;
  std::shared_ptr< sigrok::Analog const > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Logic > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Analog > **)&jarg1;
  arg1 = (sigrok::Analog *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (float)jarg2; 
  arg3 = (float)jarg3; 
  arg4 = *(uint8_t **)&jarg4; 
  arg5 = *(uint8_t **)&jarg5; 
  {
    try {
      result = ((sigrok::Analog const *)arg1)->get_logic_via_schmitt_trigger(arg2,arg3,arg4,arg5);
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Logic > **)&jresult = result ? new std::shared_ptr< sigrok::Logic >(result) : 0; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Analog_1get_1logic_1via_1schmitt_1trigger_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3, jlong jarg4) {
  jlong jresult = 0 ;
  sigrok::Analog *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  uint8_t *arg4 = 0 ;
  std::shared_ptr< sigrok::Analog const > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Logic > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Analog > **)&jarg1;
  arg1 = (sigrok::Analog *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (float)jarg2; 
  arg3 = (float)jarg3; 
  arg4 = *(uint8_t **)&jarg4; 
  {
    try {
      result = ((sigrok::Analog const *)arg1)->get_logic_via_schmitt_trigger(arg2,arg3,arg4);
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Logic > **)&jresult = result ? new std::shared_ptr< sigrok::Logic >(result) : 0; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1Analog(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::Analog *arg1 = 0 ;
  std::shared_ptr< sigrok::Analog > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Analog > **)&jarg1;
  arg1 = (sigrok::Analog *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Rational_1numerator(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Rational *arg1 = 0 ;
  int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(sigrok::Rational **)&jarg1; 
  {
    try {
      result = ((sigrok::Rational const *)arg1)->numerator();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(int64_t **)&jresult = new int64_t(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Rational_1denominator(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Rational *arg1 = 0 ;
  uint64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(sigrok::Rational **)&jarg1; 
  {
    try {
      result = ((sigrok::Rational const *)arg1)->denominator();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(uint64_t **)&jresult = new uint64_t(result); 
  return jresult;
}


SWIGEXPORT jfloat JNICALL Java_org_sigrok_core_classes_classesJNI_Rational_1value(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jfloat jresult = 0 ;
  sigrok::Rational *arg1 = 0 ;
  float result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(sigrok::Rational **)&jarg1; 
  {
    try {
      result = (float)((sigrok::Rational const *)arg1)->value();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = (jfloat)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_InputFormat_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  sigrok::InputFormat *arg1 = 0 ;
  std::shared_ptr< sigrok::InputFormat const > *smartarg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::InputFormat > **)&jarg1;
  arg1 = (sigrok::InputFormat *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::InputFormat const *)arg1)->name();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_InputFormat_1description(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  sigrok::InputFormat *arg1 = 0 ;
  std::shared_ptr< sigrok::InputFormat const > *smartarg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::InputFormat > **)&jarg1;
  arg1 = (sigrok::InputFormat *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::InputFormat const *)arg1)->description();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_InputFormat_1extensions(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::InputFormat *arg1 = 0 ;
  std::shared_ptr< sigrok::InputFormat const > *smartarg1 = 0 ;
  SwigValueWrapper< std::vector< std::string > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::InputFormat > **)&jarg1;
  arg1 = (sigrok::InputFormat *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::InputFormat const *)arg1)->extensions();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::vector< std::string > **)&jresult = new std::vector< std::string >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_InputFormat_1options(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::InputFormat *arg1 = 0 ;
  std::shared_ptr< sigrok::InputFormat > *smartarg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Option >,std::less< std::string > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::InputFormat > **)&jarg1;
  arg1 = (sigrok::InputFormat *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->options();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::map< std::string,std::shared_ptr< sigrok::Option >,std::less< std::string > > **)&jresult = new std::map< std::string,std::shared_ptr< sigrok::Option >,std::less< std::string > >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_InputFormat_1create_1input_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  sigrok::InputFormat *arg1 = 0 ;
  std::map< std::string,Glib::VariantBase,std::less< std::string > > arg2 ;
  std::shared_ptr< sigrok::InputFormat > *smartarg1 = 0 ;
  std::map< std::string,Glib::VariantBase,std::less< std::string > > *argp2 ;
  std::shared_ptr< sigrok::Input > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::InputFormat > **)&jarg1;
  arg1 = (sigrok::InputFormat *)(smartarg1 ? smartarg1->get() : 0); 
  argp2 = *(std::map< std::string,Glib::VariantBase,std::less< std::string > > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,Glib::VariantBase,std::less< std::string > >");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (arg1)->create_input(SWIG_STD_MOVE(arg2));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Input > **)&jresult = result ? new std::shared_ptr< sigrok::Input >(result) : 0; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_InputFormat_1create_1input_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::InputFormat *arg1 = 0 ;
  std::shared_ptr< sigrok::InputFormat > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Input > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::InputFormat > **)&jarg1;
  arg1 = (sigrok::InputFormat *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->create_input();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Input > **)&jresult = result ? new std::shared_ptr< sigrok::Input >(result) : 0; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1InputFormat(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::InputFormat *arg1 = 0 ;
  std::shared_ptr< sigrok::InputFormat > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::InputFormat > **)&jarg1;
  arg1 = (sigrok::InputFormat *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Input_1device(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Input *arg1 = 0 ;
  std::shared_ptr< sigrok::Input > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::InputDevice > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Input > **)&jarg1;
  arg1 = (sigrok::Input *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->device();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::InputDevice > **)&jresult = result ? new std::shared_ptr< sigrok::InputDevice >(result) : 0; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Input_1send(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) {
  sigrok::Input *arg1 = 0 ;
  void *arg2 = 0 ;
  size_t arg3 ;
  std::shared_ptr< sigrok::Input > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Input > **)&jarg1;
  arg1 = (sigrok::Input *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = *(void **)&jarg2; 
  arg3 = (size_t)jarg3; 
  {
    try {
      (arg1)->send(arg2,SWIG_STD_MOVE(arg3));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Input_1end(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  sigrok::Input *arg1 = 0 ;
  std::shared_ptr< sigrok::Input > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Input > **)&jarg1;
  arg1 = (sigrok::Input *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (arg1)->end();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_Input_1reset(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  sigrok::Input *arg1 = 0 ;
  std::shared_ptr< sigrok::Input > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Input > **)&jarg1;
  arg1 = (sigrok::Input *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (arg1)->reset();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1Input(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::Input *arg1 = 0 ;
  std::shared_ptr< sigrok::Input > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Input > **)&jarg1;
  arg1 = (sigrok::Input *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1InputDevice(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::InputDevice *arg1 = 0 ;
  std::shared_ptr< sigrok::InputDevice > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::InputDevice > **)&jarg1;
  arg1 = (sigrok::InputDevice *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_Option_1id(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  sigrok::Option *arg1 = 0 ;
  std::shared_ptr< sigrok::Option const > *smartarg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Option > **)&jarg1;
  arg1 = (sigrok::Option *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::Option const *)arg1)->id();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_Option_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  sigrok::Option *arg1 = 0 ;
  std::shared_ptr< sigrok::Option const > *smartarg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Option > **)&jarg1;
  arg1 = (sigrok::Option *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::Option const *)arg1)->name();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_Option_1description(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  sigrok::Option *arg1 = 0 ;
  std::shared_ptr< sigrok::Option const > *smartarg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Option > **)&jarg1;
  arg1 = (sigrok::Option *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::Option const *)arg1)->description();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Option_1default_1value(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Option *arg1 = 0 ;
  std::shared_ptr< sigrok::Option const > *smartarg1 = 0 ;
  Glib::VariantBase result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Option > **)&jarg1;
  arg1 = (sigrok::Option *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::Option const *)arg1)->default_value();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(Glib::VariantBase **)&jresult = new Glib::VariantBase(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Option_1values(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Option *arg1 = 0 ;
  std::shared_ptr< sigrok::Option const > *smartarg1 = 0 ;
  std::vector< Glib::VariantBase > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::Option > **)&jarg1;
  arg1 = (sigrok::Option *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::Option const *)arg1)->values();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::vector< Glib::VariantBase > **)&jresult = new std::vector< Glib::VariantBase >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Option_1parse_1string(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  sigrok::Option *arg1 = 0 ;
  std::string arg2 ;
  std::shared_ptr< sigrok::Option > *smartarg1 = 0 ;
  Glib::VariantBase result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Option > **)&jarg1;
  arg1 = (sigrok::Option *)(smartarg1 ? smartarg1->get() : 0); 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  (&arg2)->assign(arg2_pstr);
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = (arg1)->parse_string(SWIG_STD_MOVE(arg2));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(Glib::VariantBase **)&jresult = new Glib::VariantBase(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1Option(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::Option *arg1 = 0 ;
  std::shared_ptr< sigrok::Option > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Option > **)&jarg1;
  arg1 = (sigrok::Option *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFormat_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  sigrok::OutputFormat *arg1 = 0 ;
  std::shared_ptr< sigrok::OutputFormat const > *smartarg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::OutputFormat > **)&jarg1;
  arg1 = (sigrok::OutputFormat *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::OutputFormat const *)arg1)->name();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFormat_1description(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  sigrok::OutputFormat *arg1 = 0 ;
  std::shared_ptr< sigrok::OutputFormat const > *smartarg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::OutputFormat > **)&jarg1;
  arg1 = (sigrok::OutputFormat *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::OutputFormat const *)arg1)->description();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFormat_1extensions(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::OutputFormat *arg1 = 0 ;
  std::shared_ptr< sigrok::OutputFormat const > *smartarg1 = 0 ;
  SwigValueWrapper< std::vector< std::string > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::OutputFormat > **)&jarg1;
  arg1 = (sigrok::OutputFormat *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((sigrok::OutputFormat const *)arg1)->extensions();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::vector< std::string > **)&jresult = new std::vector< std::string >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFormat_1options(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::OutputFormat *arg1 = 0 ;
  std::shared_ptr< sigrok::OutputFormat > *smartarg1 = 0 ;
  std::map< std::string,std::shared_ptr< sigrok::Option >,std::less< std::string > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::OutputFormat > **)&jarg1;
  arg1 = (sigrok::OutputFormat *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->options();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::map< std::string,std::shared_ptr< sigrok::Option >,std::less< std::string > > **)&jresult = new std::map< std::string,std::shared_ptr< sigrok::Option >,std::less< std::string > >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFormat_1create_1output_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  sigrok::OutputFormat *arg1 = 0 ;
  std::shared_ptr< sigrok::Device > arg2 ;
  std::map< std::string,Glib::VariantBase,std::less< std::string > > arg3 ;
  std::shared_ptr< sigrok::OutputFormat > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Device > *argp2 ;
  std::map< std::string,Glib::VariantBase,std::less< std::string > > *argp3 ;
  std::shared_ptr< sigrok::Output > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::OutputFormat > **)&jarg1;
  arg1 = (sigrok::OutputFormat *)(smartarg1 ? smartarg1->get() : 0); 
  argp2 = *(std::shared_ptr< sigrok::Device > **)&jarg2;
  if (argp2) arg2 = *argp2; 
  argp3 = *(std::map< std::string,Glib::VariantBase,std::less< std::string > > **)&jarg3; 
  if (!argp3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,Glib::VariantBase,std::less< std::string > >");
    return 0;
  }
  arg3 = *argp3; 
  {
    try {
      result = (arg1)->create_output(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Output > **)&jresult = result ? new std::shared_ptr< sigrok::Output >(result) : 0; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFormat_1create_1output_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  sigrok::OutputFormat *arg1 = 0 ;
  std::shared_ptr< sigrok::Device > arg2 ;
  std::shared_ptr< sigrok::OutputFormat > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Device > *argp2 ;
  std::shared_ptr< sigrok::Output > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::OutputFormat > **)&jarg1;
  arg1 = (sigrok::OutputFormat *)(smartarg1 ? smartarg1->get() : 0); 
  argp2 = *(std::shared_ptr< sigrok::Device > **)&jarg2;
  if (argp2) arg2 = *argp2; 
  {
    try {
      result = (arg1)->create_output(SWIG_STD_MOVE(arg2));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Output > **)&jresult = result ? new std::shared_ptr< sigrok::Output >(result) : 0; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFormat_1create_1output_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_) {
  jlong jresult = 0 ;
  sigrok::OutputFormat *arg1 = 0 ;
  std::string arg2 ;
  std::shared_ptr< sigrok::Device > arg3 ;
  std::map< std::string,Glib::VariantBase,std::less< std::string > > arg4 ;
  std::shared_ptr< sigrok::OutputFormat > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Device > *argp3 ;
  std::map< std::string,Glib::VariantBase,std::less< std::string > > *argp4 ;
  std::shared_ptr< sigrok::Output > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  (void)jarg4_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::OutputFormat > **)&jarg1;
  arg1 = (sigrok::OutputFormat *)(smartarg1 ? smartarg1->get() : 0); 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  (&arg2)->assign(arg2_pstr);
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  argp3 = *(std::shared_ptr< sigrok::Device > **)&jarg3;
  if (argp3) arg3 = *argp3; 
  argp4 = *(std::map< std::string,Glib::VariantBase,std::less< std::string > > **)&jarg4; 
  if (!argp4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,Glib::VariantBase,std::less< std::string > >");
    return 0;
  }
  arg4 = *argp4; 
  {
    try {
      result = (arg1)->create_output(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Output > **)&jresult = result ? new std::shared_ptr< sigrok::Output >(result) : 0; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFormat_1create_1output_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  sigrok::OutputFormat *arg1 = 0 ;
  std::string arg2 ;
  std::shared_ptr< sigrok::Device > arg3 ;
  std::shared_ptr< sigrok::OutputFormat > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Device > *argp3 ;
  std::shared_ptr< sigrok::Output > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::OutputFormat > **)&jarg1;
  arg1 = (sigrok::OutputFormat *)(smartarg1 ? smartarg1->get() : 0); 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  (&arg2)->assign(arg2_pstr);
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  argp3 = *(std::shared_ptr< sigrok::Device > **)&jarg3;
  if (argp3) arg3 = *argp3; 
  {
    try {
      result = (arg1)->create_output(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::Output > **)&jresult = result ? new std::shared_ptr< sigrok::Output >(result) : 0; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFormat_1test_1flag(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  sigrok::OutputFormat *arg1 = 0 ;
  sigrok::OutputFlag *arg2 = 0 ;
  std::shared_ptr< sigrok::OutputFormat const > *smartarg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  
  smartarg1 = *(std::shared_ptr< const sigrok::OutputFormat > **)&jarg1;
  arg1 = (sigrok::OutputFormat *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = *(sigrok::OutputFlag **)&jarg2; 
  {
    try {
      result = (bool)((sigrok::OutputFormat const *)arg1)->test_flag((sigrok::OutputFlag const *)arg2);
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1OutputFormat(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::OutputFormat *arg1 = 0 ;
  std::shared_ptr< sigrok::OutputFormat > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::OutputFormat > **)&jarg1;
  arg1 = (sigrok::OutputFormat *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_Output_1receive(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jstring jresult = 0 ;
  sigrok::Output *arg1 = 0 ;
  std::shared_ptr< sigrok::Packet > arg2 ;
  std::shared_ptr< sigrok::Output > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::Packet > *argp2 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Output > **)&jarg1;
  arg1 = (sigrok::Output *)(smartarg1 ? smartarg1->get() : 0); 
  argp2 = *(std::shared_ptr< sigrok::Packet > **)&jarg2;
  if (argp2) arg2 = *argp2; 
  {
    try {
      result = (arg1)->receive(SWIG_STD_MOVE(arg2));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Output_1format(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::Output *arg1 = 0 ;
  std::shared_ptr< sigrok::Output > *smartarg1 = 0 ;
  std::shared_ptr< sigrok::OutputFormat > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Output > **)&jarg1;
  arg1 = (sigrok::Output *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->format();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::shared_ptr< sigrok::OutputFormat > **)&jresult = result ? new std::shared_ptr< sigrok::OutputFormat >(result) : 0; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1Output(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::Output *arg1 = 0 ;
  std::shared_ptr< sigrok::Output > *smartarg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  
  smartarg1 = *(std::shared_ptr<  sigrok::Output > **)&jarg1;
  arg1 = (sigrok::Output *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_LogLevel_1NONE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::LogLevel *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::LogLevel *)(sigrok::LogLevel *)sigrok::LogLevel::NONE;
  *(sigrok::LogLevel **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_LogLevel_1ERR_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::LogLevel *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::LogLevel *)(sigrok::LogLevel *)sigrok::LogLevel::ERR;
  *(sigrok::LogLevel **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_LogLevel_1WARN_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::LogLevel *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::LogLevel *)(sigrok::LogLevel *)sigrok::LogLevel::WARN;
  *(sigrok::LogLevel **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_LogLevel_1INFO_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::LogLevel *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::LogLevel *)(sigrok::LogLevel *)sigrok::LogLevel::INFO;
  *(sigrok::LogLevel **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_LogLevel_1DBG_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::LogLevel *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::LogLevel *)(sigrok::LogLevel *)sigrok::LogLevel::DBG;
  *(sigrok::LogLevel **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_LogLevel_1SPEW_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::LogLevel *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::LogLevel *)(sigrok::LogLevel *)sigrok::LogLevel::SPEW;
  *(sigrok::LogLevel **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1LogLevel(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::LogLevel *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(sigrok::LogLevel **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_DataType_1UINT64_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::DataType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::DataType *)(sigrok::DataType *)sigrok::DataType::UINT64;
  *(sigrok::DataType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_DataType_1STRING_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::DataType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::DataType *)(sigrok::DataType *)sigrok::DataType::STRING;
  *(sigrok::DataType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_DataType_1BOOL_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::DataType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::DataType *)(sigrok::DataType *)sigrok::DataType::BOOL;
  *(sigrok::DataType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_DataType_1FLOAT_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::DataType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::DataType *)(sigrok::DataType *)sigrok::DataType::FLOAT;
  *(sigrok::DataType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_DataType_1RATIONAL_1PERIOD_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::DataType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::DataType *)(sigrok::DataType *)sigrok::DataType::RATIONAL_PERIOD;
  *(sigrok::DataType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_DataType_1RATIONAL_1VOLT_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::DataType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::DataType *)(sigrok::DataType *)sigrok::DataType::RATIONAL_VOLT;
  *(sigrok::DataType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_DataType_1KEYVALUE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::DataType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::DataType *)(sigrok::DataType *)sigrok::DataType::KEYVALUE;
  *(sigrok::DataType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_DataType_1UINT64_1RANGE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::DataType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::DataType *)(sigrok::DataType *)sigrok::DataType::UINT64_RANGE;
  *(sigrok::DataType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_DataType_1DOUBLE_1RANGE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::DataType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::DataType *)(sigrok::DataType *)sigrok::DataType::DOUBLE_RANGE;
  *(sigrok::DataType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_DataType_1INT32_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::DataType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::DataType *)(sigrok::DataType *)sigrok::DataType::INT32;
  *(sigrok::DataType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_DataType_1MQ_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::DataType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::DataType *)(sigrok::DataType *)sigrok::DataType::MQ;
  *(sigrok::DataType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1DataType(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::DataType *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(sigrok::DataType **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_PacketType_1HEADER_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::PacketType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::PacketType *)(sigrok::PacketType *)sigrok::PacketType::HEADER;
  *(sigrok::PacketType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_PacketType_1END_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::PacketType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::PacketType *)(sigrok::PacketType *)sigrok::PacketType::END;
  *(sigrok::PacketType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_PacketType_1META_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::PacketType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::PacketType *)(sigrok::PacketType *)sigrok::PacketType::META;
  *(sigrok::PacketType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_PacketType_1TRIGGER_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::PacketType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::PacketType *)(sigrok::PacketType *)sigrok::PacketType::TRIGGER;
  *(sigrok::PacketType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_PacketType_1LOGIC_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::PacketType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::PacketType *)(sigrok::PacketType *)sigrok::PacketType::LOGIC;
  *(sigrok::PacketType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_PacketType_1FRAME_1BEGIN_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::PacketType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::PacketType *)(sigrok::PacketType *)sigrok::PacketType::FRAME_BEGIN;
  *(sigrok::PacketType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_PacketType_1FRAME_1END_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::PacketType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::PacketType *)(sigrok::PacketType *)sigrok::PacketType::FRAME_END;
  *(sigrok::PacketType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_PacketType_1ANALOG_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::PacketType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::PacketType *)(sigrok::PacketType *)sigrok::PacketType::ANALOG;
  *(sigrok::PacketType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1PacketType(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::PacketType *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(sigrok::PacketType **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1VOLTAGE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::VOLTAGE;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1CURRENT_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::CURRENT;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1RESISTANCE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::RESISTANCE;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1CAPACITANCE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::CAPACITANCE;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1TEMPERATURE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::TEMPERATURE;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1FREQUENCY_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::FREQUENCY;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1DUTY_1CYCLE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::DUTY_CYCLE;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1CONTINUITY_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::CONTINUITY;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1PULSE_1WIDTH_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::PULSE_WIDTH;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1CONDUCTANCE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::CONDUCTANCE;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1POWER_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::POWER;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1GAIN_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::GAIN;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1SOUND_1PRESSURE_1LEVEL_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::SOUND_PRESSURE_LEVEL;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1CARBON_1MONOXIDE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::CARBON_MONOXIDE;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1RELATIVE_1HUMIDITY_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::RELATIVE_HUMIDITY;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1TIME_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::TIME;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1WIND_1SPEED_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::WIND_SPEED;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1PRESSURE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::PRESSURE;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1PARALLEL_1INDUCTANCE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::PARALLEL_INDUCTANCE;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1PARALLEL_1CAPACITANCE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::PARALLEL_CAPACITANCE;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1PARALLEL_1RESISTANCE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::PARALLEL_RESISTANCE;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1SERIES_1INDUCTANCE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::SERIES_INDUCTANCE;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1SERIES_1CAPACITANCE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::SERIES_CAPACITANCE;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1SERIES_1RESISTANCE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::SERIES_RESISTANCE;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1DISSIPATION_1FACTOR_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::DISSIPATION_FACTOR;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1QUALITY_1FACTOR_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::QUALITY_FACTOR;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1PHASE_1ANGLE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::PHASE_ANGLE;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1DIFFERENCE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::DIFFERENCE;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1COUNT_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::COUNT;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1POWER_1FACTOR_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::POWER_FACTOR;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1APPARENT_1POWER_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::APPARENT_POWER;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1MASS_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::MASS;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Quantity_1HARMONIC_1RATIO_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Quantity *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Quantity *)(sigrok::Quantity *)sigrok::Quantity::HARMONIC_RATIO;
  *(sigrok::Quantity **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1Quantity(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::Quantity *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(sigrok::Quantity **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1VOLT_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::VOLT;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1AMPERE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::AMPERE;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1OHM_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::OHM;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1FARAD_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::FARAD;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1KELVIN_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::KELVIN;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1CELSIUS_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::CELSIUS;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1FAHRENHEIT_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::FAHRENHEIT;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1HERTZ_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::HERTZ;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1PERCENTAGE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::PERCENTAGE;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1BOOLEAN_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::BOOLEAN;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1SECOND_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::SECOND;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1SIEMENS_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::SIEMENS;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1DECIBEL_1MW_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::DECIBEL_MW;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1DECIBEL_1VOLT_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::DECIBEL_VOLT;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1UNITLESS_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::UNITLESS;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1DECIBEL_1SPL_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::DECIBEL_SPL;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1CONCENTRATION_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::CONCENTRATION;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1REVOLUTIONS_1PER_1MINUTE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::REVOLUTIONS_PER_MINUTE;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1VOLT_1AMPERE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::VOLT_AMPERE;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1WATT_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::WATT;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1WATT_1HOUR_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::WATT_HOUR;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1METER_1SECOND_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::METER_SECOND;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1HECTOPASCAL_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::HECTOPASCAL;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1HUMIDITY_1293K_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::HUMIDITY_293K;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1DEGREE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::DEGREE;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1HENRY_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::HENRY;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1GRAM_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::GRAM;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1CARAT_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::CARAT;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1OUNCE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::OUNCE;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1TROY_1OUNCE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::TROY_OUNCE;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1POUND_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::POUND;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1PENNYWEIGHT_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::PENNYWEIGHT;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1GRAIN_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::GRAIN;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1TAEL_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::TAEL;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1MOMME_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::MOMME;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1TOLA_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::TOLA;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Unit_1PIECE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Unit *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Unit *)(sigrok::Unit *)sigrok::Unit::PIECE;
  *(sigrok::Unit **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1Unit(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::Unit *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(sigrok::Unit **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1AC_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::QuantityFlag *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::QuantityFlag *)(sigrok::QuantityFlag *)sigrok::QuantityFlag::AC;
  *(sigrok::QuantityFlag **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1DC_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::QuantityFlag *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::QuantityFlag *)(sigrok::QuantityFlag *)sigrok::QuantityFlag::DC;
  *(sigrok::QuantityFlag **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1RMS_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::QuantityFlag *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::QuantityFlag *)(sigrok::QuantityFlag *)sigrok::QuantityFlag::RMS;
  *(sigrok::QuantityFlag **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1DIODE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::QuantityFlag *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::QuantityFlag *)(sigrok::QuantityFlag *)sigrok::QuantityFlag::DIODE;
  *(sigrok::QuantityFlag **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1HOLD_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::QuantityFlag *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::QuantityFlag *)(sigrok::QuantityFlag *)sigrok::QuantityFlag::HOLD;
  *(sigrok::QuantityFlag **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1MAX_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::QuantityFlag *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::QuantityFlag *)(sigrok::QuantityFlag *)sigrok::QuantityFlag::MAX;
  *(sigrok::QuantityFlag **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1MIN_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::QuantityFlag *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::QuantityFlag *)(sigrok::QuantityFlag *)sigrok::QuantityFlag::MIN;
  *(sigrok::QuantityFlag **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1AUTORANGE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::QuantityFlag *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::QuantityFlag *)(sigrok::QuantityFlag *)sigrok::QuantityFlag::AUTORANGE;
  *(sigrok::QuantityFlag **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1RELATIVE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::QuantityFlag *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::QuantityFlag *)(sigrok::QuantityFlag *)sigrok::QuantityFlag::RELATIVE;
  *(sigrok::QuantityFlag **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1SPL_1FREQ_1WEIGHT_1A_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::QuantityFlag *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::QuantityFlag *)(sigrok::QuantityFlag *)sigrok::QuantityFlag::SPL_FREQ_WEIGHT_A;
  *(sigrok::QuantityFlag **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1SPL_1FREQ_1WEIGHT_1C_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::QuantityFlag *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::QuantityFlag *)(sigrok::QuantityFlag *)sigrok::QuantityFlag::SPL_FREQ_WEIGHT_C;
  *(sigrok::QuantityFlag **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1SPL_1FREQ_1WEIGHT_1Z_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::QuantityFlag *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::QuantityFlag *)(sigrok::QuantityFlag *)sigrok::QuantityFlag::SPL_FREQ_WEIGHT_Z;
  *(sigrok::QuantityFlag **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1SPL_1FREQ_1WEIGHT_1FLAT_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::QuantityFlag *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::QuantityFlag *)(sigrok::QuantityFlag *)sigrok::QuantityFlag::SPL_FREQ_WEIGHT_FLAT;
  *(sigrok::QuantityFlag **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1SPL_1TIME_1WEIGHT_1S_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::QuantityFlag *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::QuantityFlag *)(sigrok::QuantityFlag *)sigrok::QuantityFlag::SPL_TIME_WEIGHT_S;
  *(sigrok::QuantityFlag **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1SPL_1TIME_1WEIGHT_1F_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::QuantityFlag *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::QuantityFlag *)(sigrok::QuantityFlag *)sigrok::QuantityFlag::SPL_TIME_WEIGHT_F;
  *(sigrok::QuantityFlag **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1SPL_1LAT_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::QuantityFlag *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::QuantityFlag *)(sigrok::QuantityFlag *)sigrok::QuantityFlag::SPL_LAT;
  *(sigrok::QuantityFlag **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1SPL_1PCT_1OVER_1ALARM_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::QuantityFlag *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::QuantityFlag *)(sigrok::QuantityFlag *)sigrok::QuantityFlag::SPL_PCT_OVER_ALARM;
  *(sigrok::QuantityFlag **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1DURATION_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::QuantityFlag *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::QuantityFlag *)(sigrok::QuantityFlag *)sigrok::QuantityFlag::DURATION;
  *(sigrok::QuantityFlag **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1AVG_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::QuantityFlag *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::QuantityFlag *)(sigrok::QuantityFlag *)sigrok::QuantityFlag::AVG;
  *(sigrok::QuantityFlag **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1REFERENCE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::QuantityFlag *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::QuantityFlag *)(sigrok::QuantityFlag *)sigrok::QuantityFlag::REFERENCE;
  *(sigrok::QuantityFlag **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1UNSTABLE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::QuantityFlag *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::QuantityFlag *)(sigrok::QuantityFlag *)sigrok::QuantityFlag::UNSTABLE;
  *(sigrok::QuantityFlag **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1FOUR_1WIRE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::QuantityFlag *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::QuantityFlag *)(sigrok::QuantityFlag *)sigrok::QuantityFlag::FOUR_WIRE;
  *(sigrok::QuantityFlag **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1flags_1from_1mask(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  jlong jresult = 0 ;
  unsigned int arg1 ;
  std::vector< sigrok::QuantityFlag const * > result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (unsigned int)jarg1; 
  {
    try {
      result = sigrok::QuantityFlag::flags_from_mask(arg1);
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(std::vector< sigrok::QuantityFlag const * > **)&jresult = new std::vector< sigrok::QuantityFlag const * >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_QuantityFlag_1mask_1from_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< sigrok::QuantityFlag const * > arg1 ;
  std::vector< sigrok::QuantityFlag const * > *argp1 ;
  unsigned int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  argp1 = *(std::vector< sigrok::QuantityFlag const * > **)&jarg1; 
  if (!argp1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< sigrok::QuantityFlag const * >");
    return 0;
  }
  arg1 = *argp1; 
  {
    try {
      result = (unsigned int)sigrok::QuantityFlag::mask_from_flags(SWIG_STD_MOVE(arg1));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1QuantityFlag(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::QuantityFlag *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(sigrok::QuantityFlag **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerMatchType_1ZERO_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::TriggerMatchType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::TriggerMatchType *)(sigrok::TriggerMatchType *)sigrok::TriggerMatchType::ZERO;
  *(sigrok::TriggerMatchType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerMatchType_1ONE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::TriggerMatchType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::TriggerMatchType *)(sigrok::TriggerMatchType *)sigrok::TriggerMatchType::ONE;
  *(sigrok::TriggerMatchType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerMatchType_1RISING_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::TriggerMatchType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::TriggerMatchType *)(sigrok::TriggerMatchType *)sigrok::TriggerMatchType::RISING;
  *(sigrok::TriggerMatchType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerMatchType_1FALLING_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::TriggerMatchType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::TriggerMatchType *)(sigrok::TriggerMatchType *)sigrok::TriggerMatchType::FALLING;
  *(sigrok::TriggerMatchType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerMatchType_1EDGE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::TriggerMatchType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::TriggerMatchType *)(sigrok::TriggerMatchType *)sigrok::TriggerMatchType::EDGE;
  *(sigrok::TriggerMatchType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerMatchType_1OVER_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::TriggerMatchType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::TriggerMatchType *)(sigrok::TriggerMatchType *)sigrok::TriggerMatchType::OVER;
  *(sigrok::TriggerMatchType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_TriggerMatchType_1UNDER_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::TriggerMatchType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::TriggerMatchType *)(sigrok::TriggerMatchType *)sigrok::TriggerMatchType::UNDER;
  *(sigrok::TriggerMatchType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1TriggerMatchType(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::TriggerMatchType *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(sigrok::TriggerMatchType **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_OutputFlag_1INTERNAL_1IO_1HANDLING_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::OutputFlag *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::OutputFlag *)(sigrok::OutputFlag *)sigrok::OutputFlag::INTERNAL_IO_HANDLING;
  *(sigrok::OutputFlag **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1OutputFlag(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::OutputFlag *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(sigrok::OutputFlag **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelType_1LOGIC_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ChannelType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ChannelType *)(sigrok::ChannelType *)sigrok::ChannelType::LOGIC;
  *(sigrok::ChannelType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelType_1ANALOG_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ChannelType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ChannelType *)(sigrok::ChannelType *)sigrok::ChannelType::ANALOG;
  *(sigrok::ChannelType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1ChannelType(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::ChannelType *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(sigrok::ChannelType **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Capability_1GET_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Capability *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Capability *)(sigrok::Capability *)sigrok::Capability::GET;
  *(sigrok::Capability **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Capability_1SET_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Capability *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Capability *)(sigrok::Capability *)sigrok::Capability::SET;
  *(sigrok::Capability **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Capability_1LIST_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::Capability *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::Capability *)(sigrok::Capability *)sigrok::Capability::LIST;
  *(sigrok::Capability **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1Capability(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::Capability *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(sigrok::Capability **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1LOGIC_1ANALYZER_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::LOGIC_ANALYZER;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1OSCILLOSCOPE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::OSCILLOSCOPE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1MULTIMETER_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::MULTIMETER;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1DEMO_1DEV_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::DEMO_DEV;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1SOUNDLEVELMETER_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::SOUNDLEVELMETER;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1THERMOMETER_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::THERMOMETER;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1HYGROMETER_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::HYGROMETER;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1ENERGYMETER_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::ENERGYMETER;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1DEMODULATOR_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::DEMODULATOR;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1POWER_1SUPPLY_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::POWER_SUPPLY;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1LCRMETER_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::LCRMETER;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1ELECTRONIC_1LOAD_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::ELECTRONIC_LOAD;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1SCALE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::SCALE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1SIGNAL_1GENERATOR_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::SIGNAL_GENERATOR;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1POWERMETER_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::POWERMETER;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1CONN_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::CONN;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1SERIALCOMM_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::SERIALCOMM;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1MODBUSADDR_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::MODBUSADDR;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1SAMPLERATE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::SAMPLERATE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1CAPTURE_1RATIO_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::CAPTURE_RATIO;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1PATTERN_1MODE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::PATTERN_MODE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1RLE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::RLE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1TRIGGER_1SLOPE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::TRIGGER_SLOPE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1AVERAGING_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::AVERAGING;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1AVG_1SAMPLES_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::AVG_SAMPLES;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1TRIGGER_1SOURCE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::TRIGGER_SOURCE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1HORIZ_1TRIGGERPOS_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::HORIZ_TRIGGERPOS;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1BUFFERSIZE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::BUFFERSIZE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1TIMEBASE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::TIMEBASE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1FILTER_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::FILTER;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1VDIV_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::VDIV;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1COUPLING_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::COUPLING;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1TRIGGER_1MATCH_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::TRIGGER_MATCH;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1SAMPLE_1INTERVAL_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::SAMPLE_INTERVAL;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1NUM_1HDIV_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::NUM_HDIV;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1NUM_1VDIV_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::NUM_VDIV;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1SPL_1WEIGHT_1FREQ_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::SPL_WEIGHT_FREQ;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1SPL_1WEIGHT_1TIME_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::SPL_WEIGHT_TIME;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1SPL_1MEASUREMENT_1RANGE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::SPL_MEASUREMENT_RANGE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1HOLD_1MAX_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::HOLD_MAX;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1HOLD_1MIN_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::HOLD_MIN;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1VOLTAGE_1THRESHOLD_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::VOLTAGE_THRESHOLD;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1EXTERNAL_1CLOCK_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::EXTERNAL_CLOCK;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1SWAP_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::SWAP;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1CENTER_1FREQUENCY_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::CENTER_FREQUENCY;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1NUM_1LOGIC_1CHANNELS_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::NUM_LOGIC_CHANNELS;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1NUM_1ANALOG_1CHANNELS_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::NUM_ANALOG_CHANNELS;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1VOLTAGE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::VOLTAGE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1VOLTAGE_1TARGET_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::VOLTAGE_TARGET;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1CURRENT_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::CURRENT;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1CURRENT_1LIMIT_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::CURRENT_LIMIT;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1ENABLED_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::ENABLED;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1CHANNEL_1CONFIG_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::CHANNEL_CONFIG;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1OVER_1VOLTAGE_1PROTECTION_1ENABLED_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::OVER_VOLTAGE_PROTECTION_ENABLED;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1OVER_1VOLTAGE_1PROTECTION_1ACTIVE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::OVER_VOLTAGE_PROTECTION_ACTIVE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1OVER_1VOLTAGE_1PROTECTION_1THRESHOLD_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::OVER_VOLTAGE_PROTECTION_THRESHOLD;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1OVER_1CURRENT_1PROTECTION_1ENABLED_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::OVER_CURRENT_PROTECTION_ENABLED;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1OVER_1CURRENT_1PROTECTION_1ACTIVE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::OVER_CURRENT_PROTECTION_ACTIVE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1OVER_1CURRENT_1PROTECTION_1THRESHOLD_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::OVER_CURRENT_PROTECTION_THRESHOLD;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1CLOCK_1EDGE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::CLOCK_EDGE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1AMPLITUDE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::AMPLITUDE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1REGULATION_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::REGULATION;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1OVER_1TEMPERATURE_1PROTECTION_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::OVER_TEMPERATURE_PROTECTION;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1OUTPUT_1FREQUENCY_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::OUTPUT_FREQUENCY;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1OUTPUT_1FREQUENCY_1TARGET_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::OUTPUT_FREQUENCY_TARGET;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1MEASURED_1QUANTITY_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::MEASURED_QUANTITY;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1EQUIV_1CIRCUIT_1MODEL_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::EQUIV_CIRCUIT_MODEL;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1OVER_1TEMPERATURE_1PROTECTION_1ACTIVE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::OVER_TEMPERATURE_PROTECTION_ACTIVE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1UNDER_1VOLTAGE_1CONDITION_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::UNDER_VOLTAGE_CONDITION;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1UNDER_1VOLTAGE_1CONDITION_1ACTIVE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::UNDER_VOLTAGE_CONDITION_ACTIVE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1TRIGGER_1LEVEL_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::TRIGGER_LEVEL;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1UNDER_1VOLTAGE_1CONDITION_1THRESHOLD_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::UNDER_VOLTAGE_CONDITION_THRESHOLD;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1EXTERNAL_1CLOCK_1SOURCE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::EXTERNAL_CLOCK_SOURCE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1OFFSET_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::OFFSET;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1TRIGGER_1PATTERN_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::TRIGGER_PATTERN;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1HIGH_1RESOLUTION_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::HIGH_RESOLUTION;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1PEAK_1DETECTION_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::PEAK_DETECTION;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1LOGIC_1THRESHOLD_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::LOGIC_THRESHOLD;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1LOGIC_1THRESHOLD_1CUSTOM_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::LOGIC_THRESHOLD_CUSTOM;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1RANGE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::RANGE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1DIGITS_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::DIGITS;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1SESSIONFILE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::SESSIONFILE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1CAPTUREFILE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::CAPTUREFILE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1CAPTURE_1UNITSIZE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::CAPTURE_UNITSIZE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1POWER_1OFF_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::POWER_OFF;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1DATA_1SOURCE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::DATA_SOURCE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1PROBE_1FACTOR_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::PROBE_FACTOR;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1ADC_1POWERLINE_1CYCLES_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::ADC_POWERLINE_CYCLES;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1LIMIT_1MSEC_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::LIMIT_MSEC;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1LIMIT_1SAMPLES_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::LIMIT_SAMPLES;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1LIMIT_1FRAMES_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::LIMIT_FRAMES;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1CONTINUOUS_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::CONTINUOUS;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1DATALOG_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::DATALOG;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1DEVICE_1MODE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::DEVICE_MODE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1TEST_1MODE_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (sigrok::ConfigKey *)(sigrok::ConfigKey *)sigrok::ConfigKey::TEST_MODE;
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1data_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *arg1 = 0 ;
  sigrok::DataType *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(sigrok::ConfigKey **)&jarg1; 
  {
    try {
      result = (sigrok::DataType *)((sigrok::ConfigKey const *)arg1)->data_type();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(sigrok::DataType **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1identifier(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  sigrok::ConfigKey *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(sigrok::ConfigKey **)&jarg1; 
  {
    try {
      result = ((sigrok::ConfigKey const *)arg1)->identifier();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1description(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  sigrok::ConfigKey *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(sigrok::ConfigKey **)&jarg1; 
  {
    try {
      result = ((sigrok::ConfigKey const *)arg1)->description();
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1get_1by_1identifier(JNIEnv *jenv, jclass jcls, jstring jarg1) {
  jlong jresult = 0 ;
  std::string arg1 ;
  sigrok::ConfigKey *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  if(!jarg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg1_pstr = jenv->GetStringUTFChars(jarg1, 0); 
  if (!arg1_pstr) return 0;
  (&arg1)->assign(arg1_pstr);
  jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
  {
    try {
      result = (sigrok::ConfigKey *)sigrok::ConfigKey::get_by_identifier(SWIG_STD_MOVE(arg1));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(sigrok::ConfigKey **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1parse_1string_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jint jarg2) {
  jlong jresult = 0 ;
  std::string arg1 ;
  enum sr_datatype arg2 ;
  Glib::VariantBase result;
  
  (void)jenv;
  (void)jcls;
  if(!jarg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg1_pstr = jenv->GetStringUTFChars(jarg1, 0); 
  if (!arg1_pstr) return 0;
  (&arg1)->assign(arg1_pstr);
  jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
  arg2 = (enum sr_datatype)jarg2; 
  {
    try {
      result = sigrok::ConfigKey::parse_string(SWIG_STD_MOVE(arg1),arg2);
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(Glib::VariantBase **)&jresult = new Glib::VariantBase(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ConfigKey_1parse_1string_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  sigrok::ConfigKey *arg1 = 0 ;
  std::string arg2 ;
  Glib::VariantBase result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(sigrok::ConfigKey **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  (&arg2)->assign(arg2_pstr);
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = ((sigrok::ConfigKey const *)arg1)->parse_string(SWIG_STD_MOVE(arg2));
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return 0; 
      }
      ;
    }
  }
  *(Glib::VariantBase **)&jresult = new Glib::VariantBase(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_sigrok_core_classes_classesJNI_delete_1ConfigKey(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  sigrok::ConfigKey *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(sigrok::ConfigKey **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (sigrok::Error &e) {
      {
        SWIG_JavaException(jenv, swig_exception_code(e.result), const_cast<char*>(e.what())); return ; 
      }
      ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Driver_1SWIGSmartPtrUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    std::shared_ptr< sigrok::Driver > *argp1;
    (void)jenv;
    (void)jcls;
    argp1 = *(std::shared_ptr< sigrok::Driver > **)&jarg1;
    *(std::shared_ptr< sigrok::Configurable > **)&baseptr = argp1 ? new std::shared_ptr< sigrok::Configurable >(*argp1) : 0;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Device_1SWIGSmartPtrUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    std::shared_ptr< sigrok::Device > *argp1;
    (void)jenv;
    (void)jcls;
    argp1 = *(std::shared_ptr< sigrok::Device > **)&jarg1;
    *(std::shared_ptr< sigrok::Configurable > **)&baseptr = argp1 ? new std::shared_ptr< sigrok::Configurable >(*argp1) : 0;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_HardwareDevice_1SWIGSmartPtrUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    std::shared_ptr< sigrok::HardwareDevice > *argp1;
    (void)jenv;
    (void)jcls;
    argp1 = *(std::shared_ptr< sigrok::HardwareDevice > **)&jarg1;
    *(std::shared_ptr< sigrok::Device > **)&baseptr = argp1 ? new std::shared_ptr< sigrok::Device >(*argp1) : 0;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_UserDevice_1SWIGSmartPtrUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    std::shared_ptr< sigrok::UserDevice > *argp1;
    (void)jenv;
    (void)jcls;
    argp1 = *(std::shared_ptr< sigrok::UserDevice > **)&jarg1;
    *(std::shared_ptr< sigrok::Device > **)&baseptr = argp1 ? new std::shared_ptr< sigrok::Device >(*argp1) : 0;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_ChannelGroup_1SWIGSmartPtrUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    std::shared_ptr< sigrok::ChannelGroup > *argp1;
    (void)jenv;
    (void)jcls;
    argp1 = *(std::shared_ptr< sigrok::ChannelGroup > **)&jarg1;
    *(std::shared_ptr< sigrok::Configurable > **)&baseptr = argp1 ? new std::shared_ptr< sigrok::Configurable >(*argp1) : 0;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_SessionDevice_1SWIGSmartPtrUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    std::shared_ptr< sigrok::SessionDevice > *argp1;
    (void)jenv;
    (void)jcls;
    argp1 = *(std::shared_ptr< sigrok::SessionDevice > **)&jarg1;
    *(std::shared_ptr< sigrok::Device > **)&baseptr = argp1 ? new std::shared_ptr< sigrok::Device >(*argp1) : 0;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Header_1SWIGSmartPtrUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    std::shared_ptr< sigrok::Header > *argp1;
    (void)jenv;
    (void)jcls;
    argp1 = *(std::shared_ptr< sigrok::Header > **)&jarg1;
    *(std::shared_ptr< sigrok::PacketPayload > **)&baseptr = argp1 ? new std::shared_ptr< sigrok::PacketPayload >(*argp1) : 0;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Meta_1SWIGSmartPtrUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    std::shared_ptr< sigrok::Meta > *argp1;
    (void)jenv;
    (void)jcls;
    argp1 = *(std::shared_ptr< sigrok::Meta > **)&jarg1;
    *(std::shared_ptr< sigrok::PacketPayload > **)&baseptr = argp1 ? new std::shared_ptr< sigrok::PacketPayload >(*argp1) : 0;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Logic_1SWIGSmartPtrUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    std::shared_ptr< sigrok::Logic > *argp1;
    (void)jenv;
    (void)jcls;
    argp1 = *(std::shared_ptr< sigrok::Logic > **)&jarg1;
    *(std::shared_ptr< sigrok::PacketPayload > **)&baseptr = argp1 ? new std::shared_ptr< sigrok::PacketPayload >(*argp1) : 0;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_Analog_1SWIGSmartPtrUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    std::shared_ptr< sigrok::Analog > *argp1;
    (void)jenv;
    (void)jcls;
    argp1 = *(std::shared_ptr< sigrok::Analog > **)&jarg1;
    *(std::shared_ptr< sigrok::PacketPayload > **)&baseptr = argp1 ? new std::shared_ptr< sigrok::PacketPayload >(*argp1) : 0;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_org_sigrok_core_classes_classesJNI_InputDevice_1SWIGSmartPtrUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    std::shared_ptr< sigrok::InputDevice > *argp1;
    (void)jenv;
    (void)jcls;
    argp1 = *(std::shared_ptr< sigrok::InputDevice > **)&jarg1;
    *(std::shared_ptr< sigrok::Device > **)&baseptr = argp1 ? new std::shared_ptr< sigrok::Device >(*argp1) : 0;
    return baseptr;
}

#ifdef __cplusplus
}
#endif

