[libsigrok.git] / bindings / java / org / sigrok / core / classes / classes.i

%module classes

/* Automatically load JNI library. */
%pragma(java) jniclasscode=%{
  static {
    System.loadLibrary("sigrok_java_core_classes");
  }
%}

/* Documentation & importing interfaces. */
%pragma(java) jniclassimports=%{
/**
 * @mainpage API Reference
 * 
 * Introduction
 * ------------
 * 
 * The sigrok-java API provides an object-oriented Java interface to the
 * functionality in libsigrok. It is built on top of the libsigrokcxx C++ API.
 * 
 * Getting started
 * ---------------
 * 
 * Usage of the sigrok-java API needs to begin with a call to Context.create().
 * This will create the global libsigrok context and returns a Context object.
 * Methods on this object provide access to the hardware drivers, input and
 * output formats supported by the library, as well as means of creating other
 * objects such as sessions and triggers.
 * 
 * Error handling
 * --------------
 * 
 * When any libsigrok C API call returns an error, an Error exception is raised,
 * which provides access to the error code and description.
 */

import org.sigrok.core.interfaces.LogCallback;
import org.sigrok.core.interfaces.DatafeedCallback;
%}

/* Map Glib::VariantBase to a Variant class in Java */
%rename(Variant) VariantBase;
namespace Glib {
  class VariantBase {};
}

%include "bindings/swig/templates.i"

/* Map between std::vector and java.util.Vector */
%define VECTOR(CValue, JValue)

%typemap(jni) std::vector< CValue > "jobject"
%typemap(jtype) std::vector< CValue > "java.util.Vector<JValue>"
%typemap(jstype) std::vector< CValue > "java.util.Vector<JValue>"

%typemap(javain,
    pre="  $javaclassname temp$javainput = new $javaclassname();
  for (JValue value : $javainput)
    temp$javainput.add(value);",
    pgcppname="temp$javainput")
  std::vector< CValue > "$javaclassname.getCPtr(temp$javainput)"

%typemap(javaout) std::vector< CValue > {
  return (java.util.Vector<JValue>)$jnicall;
}

%typemap(out) std::vector< CValue > {
  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/" #JValue);
  jmethodID Value_init = jenv->GetMethodID(Value, "<init>", "(JZ)V");
  $result = jenv->NewObject(Vector, Vector_init);
  jlong value;
  for (auto entry : $1)
  {
    *(CValue **) &value = new CValue(entry);
    jenv->CallObjectMethod($result, Vector_add,
      jenv->NewObject(Value, Value_init, value, true));
  }
}

%enddef

VECTOR(std::shared_ptr<sigrok::Channel>, Channel)
VECTOR(std::shared_ptr<sigrok::HardwareDevice>, HardwareDevice)

/* Common macro for mapping between std::map and java.util.Map */

%define MAP_COMMON(CKey, CValue, JKey, JValue)

%typemap(jstype) std::map< CKey, CValue >
  "java.util.Map<JKey, JValue>"

%typemap(javain,
    pre="  $javaclassname temp$javainput = new $javaclassname();
    for (java.util.Map.Entry<JKey, JValue> entry : $javainput.entrySet())
      temp$javainput.set(entry.getKey(), entry.getValue());",
    pgcppname="temp$javainput")
  std::map< CKey, CValue > "$javaclassname.getCPtr(temp$javainput)"

%typemap(javaout) std::map< CKey, CValue > {
  return (java.util.Map<JKey, JValue>)$jnicall;
}

%enddef

/* Specialisation for string->string maps. */

MAP_COMMON(std::string, std::string, String, String)

%typemap(jni) std::map<std::string, std::string>
  "jobject"
%typemap(jtype) std::map<std::string, std::string>
  "java.util.Map<String,String>"

%typemap(out) std::map<std::string, std::string> {
  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;");
  $result = jenv->NewObject(HashMap, init);
  for (auto entry : $1)
    jenv->CallObjectMethod($result, put,
      jenv->NewStringUTF(entry.first.c_str()),
      jenv->NewStringUTF(entry.second.c_str()));
}

/* Specialisation macro for string->shared_ptr maps. */

%define STRING_TO_SHARED_PTR_MAP(ClassName)

%typemap(jni) std::map<std::string, std::shared_ptr<sigrok::ClassName> >
  "jobject"
%typemap(jtype) std::map<std::string, std::shared_ptr<sigrok::ClassName> >
  "java.util.Map<String,ClassName>"

MAP_COMMON(std::string, std::shared_ptr<sigrok::ClassName>, String, ClassName)

%typemap(out) std::map<std::string, std::shared_ptr<sigrok::ClassName> > {
  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/" #ClassName);
  jmethodID Value_init = jenv->GetMethodID(Value, "<init>", "(JZ)V");
  $result = jenv->NewObject(HashMap, HashMap_init);
  jlong value;
  for (auto entry : $1)
  {
    *(std::shared_ptr< sigrok::ClassName > **)&value =
      new std::shared_ptr< sigrok::ClassName>(entry.second);
    jenv->CallObjectMethod($result, HashMap_put,
      jenv->NewStringUTF(entry.first.c_str()),
      jenv->NewObject(Value, Value_init, value, true));
  }
}

%enddef

STRING_TO_SHARED_PTR_MAP(Driver)
STRING_TO_SHARED_PTR_MAP(InputFormat)
STRING_TO_SHARED_PTR_MAP(OutputFormat)

/* Specialisation for ConfigKey->Variant maps */

MAP_COMMON(const sigrok::ConfigKey *, Glib::VariantBase, ConfigKey, Variant)

%typemap(jni) std::map<const sigrok::ConfigKey, Glib::VariantBase> "jobject"
%typemap(jtype) std::map<const sigrok::ConfigKey, Glib::VariantBase>
  "java.util.Map<ConfigKey,Variant>"

%typemap(out) std::map<const sigrok::ConfigKey *, Glib::VariantBase> {
  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 ConfigKey = jenv->FindClass("org/sigrok/core/classes/ConfigKey");
  jmethodID ConfigKey_init = jenv->GetMethodID(ConfigKey, "<init>", "(JZ)V");
  jclass Variant = jenv->FindClass("org/sigrok/core/classes/Variant");
  jmethodID Variant_init = jenv->GetMethodID(Variant, "<init>", "(JZ)V");
  $result = jenv->NewObject(HashMap, HashMap_init);
  jlong key;
  jlong value;
  for (auto entry : $1)
  {
    *(const sigrok::ConfigKey **) &key = entry.first;
    *(Glib::VariantBase **) &value = new Glib::VariantBase(entry.second);
    jenv->CallObjectMethod($result, HashMap_put,
      jenv->NewObject(ConfigKey, ConfigKey_init, key, false));
      jenv->NewObject(Variant, Variant_init, value, true));
  }
}

/* Pass JNIEnv parameter to C++ extension methods requiring it. */

%typemap(in, numinputs=0) JNIEnv * %{
   $1 = jenv;
%} 

/* Support Java log callbacks. */

%typemap(javaimports) sigrok::Context
  "import org.sigrok.core.interfaces.LogCallback;"

%inline {
typedef jobject jlogcallback;
}

%typemap(jni) jlogcallback "jlogcallback"
%typemap(jtype) jlogcallback "LogCallback"
%typemap(jstype) jlogcallback "LogCallback"
%typemap(javain) jlogcallback "$javainput"

%extend sigrok::Context
{
  void add_log_callback(JNIEnv *env, jlogcallback obj)
  {
    jclass obj_class = env->GetObjectClass(obj);
    jmethodID method = env->GetMethodID(obj_class, "run",
      "(Lorg/sigrok/core/classes/LogLevel;Ljava/lang/String;)V");
    jclass LogLevel = (jclass) env->NewGlobalRef(
        env->FindClass("org/sigrok/core/classes/LogLevel"));
    jmethodID LogLevel_init = env->GetMethodID(LogLevel, "<init>", "(JZ)V");
    jobject obj_ref = env->NewGlobalRef(obj);

    $self->set_log_callback([=] (
      const sigrok::LogLevel *loglevel,
      std::string message)
    {
      jlong loglevel_addr;
      *(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);
    });
  }
}

/* Support Java datafeed callbacks. */

%typemap(javaimports) sigrok::Session
  "import org.sigrok.core.interfaces.DatafeedCallback;"

%inline {
typedef jobject jdatafeedcallback;
}

%typemap(jni) jdatafeedcallback "jdatafeedcallback"
%typemap(jtype) jdatafeedcallback "DatafeedCallback"
%typemap(jstype) jdatafeedcallback "DatafeedCallback"
%typemap(javain) jdatafeedcallback "$javainput"

%extend sigrok::Session
{
  void add_datafeed_callback(JNIEnv *env, jdatafeedcallback obj)
  {
    jclass obj_class = env->GetObjectClass(obj);
    jmethodID method = env->GetMethodID(obj_class, "run",
      "(Lorg/sigrok/core/classes/Device;Lorg/sigrok/core/classes/Packet;)V");
    jclass Device = (jclass) env->NewGlobalRef(
        env->FindClass("org/sigrok/core/classes/Device"));
    jmethodID Device_init = env->GetMethodID(Device, "<init>", "(JZ)V");
    jclass Packet = (jclass) env->NewGlobalRef(
       env->FindClass("org/sigrok/core/classes/Packet"));
    jmethodID Packet_init = env->GetMethodID(Packet, "<init>", "(JZ)V");
    jobject obj_ref = env->NewGlobalRef(obj);

    $self->add_datafeed_callback([=] (
      std::shared_ptr<sigrok::Device> device,
      std::shared_ptr<sigrok::Packet> packet)
    {
      jlong device_addr;
      jlong packet_addr;
      *(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);
    });
  }
}

%include "doc.i"

%define %enumextras(Class)
%enddef

/* Ignore these for now, need fixes. */
%ignore sigrok::Context::create_analog_packet;
%ignore sigrok::Context::create_meta_packet;
%ignore sigrok::Meta::config;

%include "bindings/swig/classes.i"
Commit	Line	Data
9fcf4d0b ML	1	%module classes
	2
	3	/* Automatically load JNI library. */
	4	%pragma(java) jniclasscode=%{
	5	static {
	6	System.loadLibrary("sigrok_java_core_classes");
	7	}
	8	%}
	9
8a314e90	10	/* Documentation & importing interfaces. */
90bd7656	11	%pragma(java) jniclassimports=%{
8a314e90 ML	12	/**
	13	* @mainpage API Reference
	14	*
	15	* Introduction
	16	* ------------
	17	*
	18	* The sigrok-java API provides an object-oriented Java interface to the
52ff4f6a	19	* functionality in libsigrok. It is built on top of the libsigrokcxx C++ API.
8a314e90 ML	20	*
	21	* Getting started
	22	* ---------------
	23	*
	24	* Usage of the sigrok-java API needs to begin with a call to Context.create().
	25	* This will create the global libsigrok context and returns a Context object.
	26	* Methods on this object provide access to the hardware drivers, input and
	27	* output formats supported by the library, as well as means of creating other
	28	* objects such as sessions and triggers.
	29	*
	30	* Error handling
	31	* --------------
	32	*
	33	* When any libsigrok C API call returns an error, an Error exception is raised,
	34	* which provides access to the error code and description.
	35	*/
	36
	37	import org.sigrok.core.interfaces.LogCallback;
	38	import org.sigrok.core.interfaces.DatafeedCallback;
90bd7656 ML	39	%}
90bd7656 ML	40
9fcf4d0b ML	41	/* Map Glib::VariantBase to a Variant class in Java */
	42	%rename(Variant) VariantBase;
	43	namespace Glib {
	44	class VariantBase {};
	45	}
	46
c7855def ML	47	%include "bindings/swig/templates.i"
c7855def ML	48
9fcf4d0b ML	49	/* Map between std::vector and java.util.Vector */
	50	%define VECTOR(CValue, JValue)
	51
	52	%typemap(jni) std::vector< CValue > "jobject"
	53	%typemap(jtype) std::vector< CValue > "java.util.Vector<JValue>"
	54	%typemap(jstype) std::vector< CValue > "java.util.Vector<JValue>"
	55
	56	%typemap(javain,
f3095e7e ML	57	pre=" $javaclassname temp$javainput = new $javaclassname();
	58	for (JValue value : $javainput)
	59	temp$javainput.add(value);",
9fcf4d0b ML	60	pgcppname="temp$javainput")
	61	std::vector< CValue > "$javaclassname.getCPtr(temp$javainput)"
	62
9fcf4d0b ML	63	%typemap(javaout) std::vector< CValue > {
	64	return (java.util.Vector<JValue>)$jnicall;
	65	}
	66
	67	%typemap(out) std::vector< CValue > {
	68	jclass Vector = jenv->FindClass("java/util/Vector");
	69	jmethodID Vector_init = jenv->GetMethodID(Vector, "<init>", "()V");
	70	jmethodID Vector_add = jenv->GetMethodID(Vector, "add",
	71	"(Ljava/lang/Object;)Z");
	72	jclass Value = jenv->FindClass("org/sigrok/core/classes/" #JValue);
	73	jmethodID Value_init = jenv->GetMethodID(Value, "<init>", "(JZ)V");
	74	$result = jenv->NewObject(Vector, Vector_init);
	75	jlong value;
	76	for (auto entry : $1)
	77	{
	78	(CValue *) &value = new CValue(entry);
	79	jenv->CallObjectMethod($result, Vector_add,
	80	jenv->NewObject(Value, Value_init, value, true));
	81	}
	82	}
	83
	84	%enddef
	85
	86	VECTOR(std::shared_ptr<sigrok::Channel>, Channel)
	87	VECTOR(std::shared_ptr<sigrok::HardwareDevice>, HardwareDevice)
	88
	89	/* Common macro for mapping between std::map and java.util.Map */
	90
	91	%define MAP_COMMON(CKey, CValue, JKey, JValue)
	92
	93	%typemap(jstype) std::map< CKey, CValue >
	94	"java.util.Map<JKey, JValue>"
	95
	96	%typemap(javain,
f3095e7e ML	97	pre=" $javaclassname temp$javainput = new $javaclassname();
	98	for (java.util.Map.Entry<JKey, JValue> entry : $javainput.entrySet())
	99	temp$javainput.set(entry.getKey(), entry.getValue());",
9fcf4d0b ML	100	pgcppname="temp$javainput")
	101	std::map< CKey, CValue > "$javaclassname.getCPtr(temp$javainput)"
	102
9fcf4d0b ML	103	%typemap(javaout) std::map< CKey, CValue > {
	104	return (java.util.Map<JKey, JValue>)$jnicall;
	105	}
	106
	107	%enddef
	108
	109	/* Specialisation for string->string maps. */
	110
	111	MAP_COMMON(std::string, std::string, String, String)
	112
24287ea9 AJ	113	%typemap(jni) std::map<std::string, std::string>
	114	"jobject"
	115	%typemap(jtype) std::map<std::string, std::string>
	116	"java.util.Map<String,String>"
	117
9fcf4d0b ML	118	%typemap(out) std::map<std::string, std::string> {
	119	jclass HashMap = jenv->FindClass("java/util/HashMap");
	120	jmethodID init = jenv->GetMethodID(HashMap, "<init>", "()V");
	121	jmethodID put = jenv->GetMethodID(HashMap, "put",
	122	"(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
	123	$result = jenv->NewObject(HashMap, init);
	124	for (auto entry : $1)
	125	jenv->CallObjectMethod($result, put,
	126	jenv->NewStringUTF(entry.first.c_str()),
	127	jenv->NewStringUTF(entry.second.c_str()));
	128	}
	129
	130	/* Specialisation macro for string->shared_ptr maps. */
	131
	132	%define STRING_TO_SHARED_PTR_MAP(ClassName)
	133
	134	%typemap(jni) std::map<std::string, std::shared_ptr<sigrok::ClassName> >
	135	"jobject"
	136	%typemap(jtype) std::map<std::string, std::shared_ptr<sigrok::ClassName> >
	137	"java.util.Map<String,ClassName>"
	138
	139	MAP_COMMON(std::string, std::shared_ptr<sigrok::ClassName>, String, ClassName)
	140
	141	%typemap(out) std::map<std::string, std::shared_ptr<sigrok::ClassName> > {
	142	jclass HashMap = jenv->FindClass("java/util/HashMap");
	143	jmethodID HashMap_init = jenv->GetMethodID(HashMap, "<init>", "()V");
	144	jmethodID HashMap_put = jenv->GetMethodID(HashMap, "put",
	145	"(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
	146	jclass Value = jenv->FindClass("org/sigrok/core/classes/" #ClassName);
	147	jmethodID Value_init = jenv->GetMethodID(Value, "<init>", "(JZ)V");
	148	$result = jenv->NewObject(HashMap, HashMap_init);
	149	jlong value;
	150	for (auto entry : $1)
	151	{
	152	(std::shared_ptr< sigrok::ClassName > *)&value =
	153	new std::shared_ptr< sigrok::ClassName>(entry.second);
	154	jenv->CallObjectMethod($result, HashMap_put,
	155	jenv->NewStringUTF(entry.first.c_str()),
	156	jenv->NewObject(Value, Value_init, value, true));
	157	}
	158	}
	159
	160	%enddef
	161
	162	STRING_TO_SHARED_PTR_MAP(Driver)
	163	STRING_TO_SHARED_PTR_MAP(InputFormat)
	164	STRING_TO_SHARED_PTR_MAP(OutputFormat)
	165
	166	/* Specialisation for ConfigKey->Variant maps */
	167
	168	MAP_COMMON(const sigrok::ConfigKey *, Glib::VariantBase, ConfigKey, Variant)
	169
2928f47d ML	170	%typemap(jni) std::map<const sigrok::ConfigKey, Glib::VariantBase> "jobject"
	171	%typemap(jtype) std::map<const sigrok::ConfigKey, Glib::VariantBase>
	172	"java.util.Map<ConfigKey,Variant>"
	173
9fcf4d0b ML	174	%typemap(out) std::map<const sigrok::ConfigKey *, Glib::VariantBase> {
	175	jclass HashMap = jenv->FindClass("java/util/HashMap");
	176	jmethodID HashMap_init = jenv->GetMethodID(HashMap, "<init>", "()V");
	177	jmethodID HashMap_put = jenv->GetMethodID(HashMap, "put",
	178	"(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
	179	jclass ConfigKey = jenv->FindClass("org/sigrok/core/classes/ConfigKey");
	180	jmethodID ConfigKey_init = jenv->GetMethodID(ConfigKey, "<init>", "(JZ)V");
	181	jclass Variant = jenv->FindClass("org/sigrok/core/classes/Variant");
	182	jmethodID Variant_init = jenv->GetMethodID(Variant, "<init>", "(JZ)V");
	183	$result = jenv->NewObject(HashMap, HashMap_init);
	184	jlong key;
	185	jlong value;
	186	for (auto entry : $1)
	187	{
	188	(const sigrok::ConfigKey *) &key = entry.first;
	189	(Glib::VariantBase *) &value = new Glib::VariantBase(entry.second);
	190	jenv->CallObjectMethod($result, HashMap_put,
	191	jenv->NewObject(ConfigKey, ConfigKey_init, key, false));
	192	jenv->NewObject(Variant, Variant_init, value, true));
	193	}
	194	}
	195
9fcf4d0b ML	196	/* Pass JNIEnv parameter to C++ extension methods requiring it. */
	197
	198	%typemap(in, numinputs=0) JNIEnv * %{
	199	$1 = jenv;
	200	%}
	201
	202	/* Support Java log callbacks. */
	203
90bd7656 ML	204	%typemap(javaimports) sigrok::Context
	205	"import org.sigrok.core.interfaces.LogCallback;"
	206
9fcf4d0b ML	207	%inline {
	208	typedef jobject jlogcallback;
	209	}
	210
	211	%typemap(jni) jlogcallback "jlogcallback"
	212	%typemap(jtype) jlogcallback "LogCallback"
	213	%typemap(jstype) jlogcallback "LogCallback"
	214	%typemap(javain) jlogcallback "$javainput"
	215
	216	%extend sigrok::Context
	217	{
	218	void add_log_callback(JNIEnv *env, jlogcallback obj)
	219	{
	220	jclass obj_class = env->GetObjectClass(obj);
	221	jmethodID method = env->GetMethodID(obj_class, "run",
	222	"(Lorg/sigrok/core/classes/LogLevel;Ljava/lang/String;)V");
	223	jclass LogLevel = (jclass) env->NewGlobalRef(
	224	env->FindClass("org/sigrok/core/classes/LogLevel"));
	225	jmethodID LogLevel_init = env->GetMethodID(LogLevel, "<init>", "(JZ)V");
	226	jobject obj_ref = env->NewGlobalRef(obj);
	227
	228	$self->set_log_callback([=] (
	229	const sigrok::LogLevel *loglevel,
	230	std::string message)
	231	{
	232	jlong loglevel_addr;
	233	(const sigrok::LogLevel *) &loglevel_addr = loglevel;
	234	jobject loglevel_obj = env->NewObject(
	235	LogLevel, LogLevel_init, loglevel_addr, false);
	236	jobject message_obj = env->NewStringUTF(message.c_str());
	237	env->CallVoidMethod(obj_ref, method, loglevel_obj, message_obj);
	238	if (env->ExceptionCheck())
	239	throw sigrok::Error(SR_ERR);
	240	});
	241	}
	242	}
	243
	244	/* Support Java datafeed callbacks. */
	245
90bd7656 ML	246	%typemap(javaimports) sigrok::Session
	247	"import org.sigrok.core.interfaces.DatafeedCallback;"
	248
9fcf4d0b ML	249	%inline {
	250	typedef jobject jdatafeedcallback;
	251	}
	252
	253	%typemap(jni) jdatafeedcallback "jdatafeedcallback"
	254	%typemap(jtype) jdatafeedcallback "DatafeedCallback"
	255	%typemap(jstype) jdatafeedcallback "DatafeedCallback"
	256	%typemap(javain) jdatafeedcallback "$javainput"
	257
	258	%extend sigrok::Session
	259	{
	260	void add_datafeed_callback(JNIEnv *env, jdatafeedcallback obj)
	261	{
	262	jclass obj_class = env->GetObjectClass(obj);
	263	jmethodID method = env->GetMethodID(obj_class, "run",
	264	"(Lorg/sigrok/core/classes/Device;Lorg/sigrok/core/classes/Packet;)V");
	265	jclass Device = (jclass) env->NewGlobalRef(
	266	env->FindClass("org/sigrok/core/classes/Device"));
	267	jmethodID Device_init = env->GetMethodID(Device, "<init>", "(JZ)V");
	268	jclass Packet = (jclass) env->NewGlobalRef(
	269	env->FindClass("org/sigrok/core/classes/Packet"));
	270	jmethodID Packet_init = env->GetMethodID(Packet, "<init>", "(JZ)V");
	271	jobject obj_ref = env->NewGlobalRef(obj);
	272
	273	$self->add_datafeed_callback([=] (
	274	std::shared_ptr<sigrok::Device> device,
	275	std::shared_ptr<sigrok::Packet> packet)
	276	{
	277	jlong device_addr;
	278	jlong packet_addr;
	279	(std::shared_ptr<sigrok::Device> *) &device_addr =
	280	new std::shared_ptr<sigrok::Device>(device);
	281	(std::shared_ptr<sigrok::Packet> *) &packet_addr =
	282	new std::shared_ptr<sigrok::Packet>(packet);
	283	jobject device_obj = env->NewObject(
	284	Device, Device_init, device_addr, true);
	285	jobject packet_obj = env->NewObject(
	286	Packet, Packet_init, packet_addr, true);
	287	env->CallVoidMethod(obj_ref, method, device_obj, packet_obj);
	288	if (env->ExceptionCheck())
	289	throw sigrok::Error(SR_ERR);
	290	});
	291	}
	292	}
	293
bd4fda24	294	%include "doc.i"
062430a2	295
7a36ceac ML	296	%define %enumextras(Class)
	297	%enddef
	298
c7855def	299	/* Ignore these for now, need fixes. */
dd13d47a	300	%ignore sigrok::Context::create_analog_packet;
c7855def	301	%ignore sigrok::Context::create_meta_packet;
d0fa4ac1	302	%ignore sigrok::Meta::config;
b71356d6	303
9fcf4d0b	304	%include "bindings/swig/classes.i"
b71356d6	305