[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)
  {
    value = reinterpret_cast<intptr_t>(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)
  {
    value = reinterpret_cast<intptr_t>(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)
  {
    key = reinterpret_cast<intptr_t>(entry.first);
    value = reinterpret_cast<intptr_t>(new Glib::VariantBase(entry.second));
    jenv->CallObjectMethod($result, HashMap_put,
      jenv->NewObject(ConfigKey, ConfigKey_init, key, false));
      jenv->NewObject(Variant, Variant_init, value, true));
  }
}

/* Specialisation for ConfigKey->set<Capability> maps */

MAP_COMMON(const sigrok::ConfigKey *, std::set<enum sigrok::Capability>,
  ConfigKey, java.util.Set<Capability>)

%typemap(jni) std::map<const sigrok::ConfigKey *, std::set<enum sigrok::Capability> > "jobject"
%typemap(jtype) std::map<const sigrok::ConfigKey *, std::set<enum sigrok::Capability> >
  "java.util.Map<ConfigKey,java.util.Set<Capability>>"

%typemap(out) std::map<const sigrok::ConfigKey *, std::set<enum sigrok::Capability> > {
  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 HashSet = jenv->FindClass("java/util/HashSet");
  jmethodID HashSet_init = jenv->GetMethodID(HashSet, "<init>", "()V");
  jmethodID HashSet_add = jenv->GetMethodID(HashSet, "add",
    "(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 Capability = jenv->FindClass("org/sigrok/core/classes/Capability");
  jmethodID Capability_swigToEnum = jenv->GetStaticMethodID(Capability,
    "swigToEnum", "(I)Lorg/sigrok/core/classes/Capability;");
  $result = jenv->NewObject(HashMap, HashMap_init);
  jlong key;
  for (auto map_entry : $1)
  {
    key = reinterpret_cast<intptr_t>(map_entry.first);
    jobject value = jenv->NewObject(HashSet, HashSet_init);
    for (auto &set_entry : map_entry.second)
      jenv->CallObjectMethod(value, HashSet_add,
        jenv->CallStaticObjectMethod(Capability,
          Capability_swigToEnum, set_entry));
    jenv->CallObjectMethod($result, HashMap_put,
      jenv->NewObject(ConfigKey, ConfigKey_init, key, false), value);
  }
}

/* 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;
      loglevel_addr = reinterpret_cast<intptr_t>(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;
      device_addr = reinterpret_cast<intptr_t>(new std::shared_ptr<sigrok::Device>(device));
      packet_addr = reinterpret_cast<intptr_t>(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	{
865de993	78	value = reinterpret_cast<intptr_t>(new CValue(entry));
9fcf4d0b ML	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	{
865de993	152	value = reinterpret_cast<intptr_t>(new std::shared_ptr< sigrok::ClassName>(entry.second));
9fcf4d0b ML	153	jenv->CallObjectMethod($result, HashMap_put,
	154	jenv->NewStringUTF(entry.first.c_str()),
	155	jenv->NewObject(Value, Value_init, value, true));
	156	}
	157	}
	158
	159	%enddef
	160
	161	STRING_TO_SHARED_PTR_MAP(Driver)
	162	STRING_TO_SHARED_PTR_MAP(InputFormat)
	163	STRING_TO_SHARED_PTR_MAP(OutputFormat)
	164
	165	/* Specialisation for ConfigKey->Variant maps */
	166
	167	MAP_COMMON(const sigrok::ConfigKey *, Glib::VariantBase, ConfigKey, Variant)
	168
2928f47d ML	169	%typemap(jni) std::map<const sigrok::ConfigKey, Glib::VariantBase> "jobject"
	170	%typemap(jtype) std::map<const sigrok::ConfigKey, Glib::VariantBase>
	171	"java.util.Map<ConfigKey,Variant>"
	172
9fcf4d0b ML	173	%typemap(out) std::map<const sigrok::ConfigKey *, Glib::VariantBase> {
	174	jclass HashMap = jenv->FindClass("java/util/HashMap");
	175	jmethodID HashMap_init = jenv->GetMethodID(HashMap, "<init>", "()V");
	176	jmethodID HashMap_put = jenv->GetMethodID(HashMap, "put",
	177	"(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
	178	jclass ConfigKey = jenv->FindClass("org/sigrok/core/classes/ConfigKey");
	179	jmethodID ConfigKey_init = jenv->GetMethodID(ConfigKey, "<init>", "(JZ)V");
	180	jclass Variant = jenv->FindClass("org/sigrok/core/classes/Variant");
	181	jmethodID Variant_init = jenv->GetMethodID(Variant, "<init>", "(JZ)V");
	182	$result = jenv->NewObject(HashMap, HashMap_init);
	183	jlong key;
	184	jlong value;
	185	for (auto entry : $1)
	186	{
865de993 DE	187	key = reinterpret_cast<intptr_t>(entry.first);
865de993 DE	188	value = reinterpret_cast<intptr_t>(new Glib::VariantBase(entry.second));
9fcf4d0b ML	189	jenv->CallObjectMethod($result, HashMap_put,
	190	jenv->NewObject(ConfigKey, ConfigKey_init, key, false));
	191	jenv->NewObject(Variant, Variant_init, value, true));
	192	}
	193	}
	194
f2831ab3 ML	195	/* Specialisation for ConfigKey->set<Capability> maps */
	196
	197	MAP_COMMON(const sigrok::ConfigKey *, std::set<enum sigrok::Capability>,
	198	ConfigKey, java.util.Set<Capability>)
	199
b0b0e200 DE	200	%typemap(jni) std::map<const sigrok::ConfigKey *, std::set<enum sigrok::Capability> > "jobject"
b0b0e200 DE	201	%typemap(jtype) std::map<const sigrok::ConfigKey *, std::set<enum sigrok::Capability> >
f2831ab3 ML	202	"java.util.Map<ConfigKey,java.util.Set<Capability>>"
f2831ab3 ML	203
b0b0e200	204	%typemap(out) std::map<const sigrok::ConfigKey *, std::set<enum sigrok::Capability> > {
f2831ab3 ML	205	jclass HashMap = jenv->FindClass("java/util/HashMap");
	206	jmethodID HashMap_init = jenv->GetMethodID(HashMap, "<init>", "()V");
	207	jmethodID HashMap_put = jenv->GetMethodID(HashMap, "put",
	208	"(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
	209	jclass HashSet = jenv->FindClass("java/util/HashSet");
	210	jmethodID HashSet_init = jenv->GetMethodID(HashSet, "<init>", "()V");
	211	jmethodID HashSet_add = jenv->GetMethodID(HashSet, "add",
	212	"(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
	213	jclass ConfigKey = jenv->FindClass("org/sigrok/core/classes/ConfigKey");
	214	jmethodID ConfigKey_init = jenv->GetMethodID(ConfigKey, "<init>", "(JZ)V");
	215	jclass Capability = jenv->FindClass("org/sigrok/core/classes/Capability");
	216	jmethodID Capability_swigToEnum = jenv->GetStaticMethodID(Capability,
	217	"swigToEnum", "(I)Lorg/sigrok/core/classes/Capability;");
	218	$result = jenv->NewObject(HashMap, HashMap_init);
	219	jlong key;
	220	for (auto map_entry : $1)
	221	{
865de993	222	key = reinterpret_cast<intptr_t>(map_entry.first);
f2831ab3 ML	223	jobject value = jenv->NewObject(HashSet, HashSet_init);
	224	for (auto &set_entry : map_entry.second)
	225	jenv->CallObjectMethod(value, HashSet_add,
	226	jenv->CallStaticObjectMethod(Capability,
	227	Capability_swigToEnum, set_entry));
	228	jenv->CallObjectMethod($result, HashMap_put,
	229	jenv->NewObject(ConfigKey, ConfigKey_init, key, false), value);
	230	}
	231	}
	232
9fcf4d0b ML	233	/* Pass JNIEnv parameter to C++ extension methods requiring it. */
	234
	235	%typemap(in, numinputs=0) JNIEnv * %{
	236	$1 = jenv;
	237	%}
	238
	239	/* Support Java log callbacks. */
	240
90bd7656 ML	241	%typemap(javaimports) sigrok::Context
	242	"import org.sigrok.core.interfaces.LogCallback;"
	243
9fcf4d0b ML	244	%inline {
	245	typedef jobject jlogcallback;
	246	}
	247
	248	%typemap(jni) jlogcallback "jlogcallback"
	249	%typemap(jtype) jlogcallback "LogCallback"
	250	%typemap(jstype) jlogcallback "LogCallback"
	251	%typemap(javain) jlogcallback "$javainput"
	252
	253	%extend sigrok::Context
	254	{
	255	void add_log_callback(JNIEnv *env, jlogcallback obj)
	256	{
	257	jclass obj_class = env->GetObjectClass(obj);
	258	jmethodID method = env->GetMethodID(obj_class, "run",
	259	"(Lorg/sigrok/core/classes/LogLevel;Ljava/lang/String;)V");
	260	jclass LogLevel = (jclass) env->NewGlobalRef(
	261	env->FindClass("org/sigrok/core/classes/LogLevel"));
	262	jmethodID LogLevel_init = env->GetMethodID(LogLevel, "<init>", "(JZ)V");
	263	jobject obj_ref = env->NewGlobalRef(obj);
	264
	265	$self->set_log_callback([=] (
	266	const sigrok::LogLevel *loglevel,
	267	std::string message)
	268	{
	269	jlong loglevel_addr;
865de993	270	loglevel_addr = reinterpret_cast<intptr_t>(loglevel);
9fcf4d0b ML	271	jobject loglevel_obj = env->NewObject(
	272	LogLevel, LogLevel_init, loglevel_addr, false);
	273	jobject message_obj = env->NewStringUTF(message.c_str());
	274	env->CallVoidMethod(obj_ref, method, loglevel_obj, message_obj);
	275	if (env->ExceptionCheck())
	276	throw sigrok::Error(SR_ERR);
	277	});
	278	}
	279	}
	280
	281	/* Support Java datafeed callbacks. */
	282
90bd7656 ML	283	%typemap(javaimports) sigrok::Session
	284	"import org.sigrok.core.interfaces.DatafeedCallback;"
	285
9fcf4d0b ML	286	%inline {
	287	typedef jobject jdatafeedcallback;
	288	}
	289
	290	%typemap(jni) jdatafeedcallback "jdatafeedcallback"
	291	%typemap(jtype) jdatafeedcallback "DatafeedCallback"
	292	%typemap(jstype) jdatafeedcallback "DatafeedCallback"
	293	%typemap(javain) jdatafeedcallback "$javainput"
	294
	295	%extend sigrok::Session
	296	{
	297	void add_datafeed_callback(JNIEnv *env, jdatafeedcallback obj)
	298	{
	299	jclass obj_class = env->GetObjectClass(obj);
	300	jmethodID method = env->GetMethodID(obj_class, "run",
	301	"(Lorg/sigrok/core/classes/Device;Lorg/sigrok/core/classes/Packet;)V");
	302	jclass Device = (jclass) env->NewGlobalRef(
	303	env->FindClass("org/sigrok/core/classes/Device"));
	304	jmethodID Device_init = env->GetMethodID(Device, "<init>", "(JZ)V");
	305	jclass Packet = (jclass) env->NewGlobalRef(
	306	env->FindClass("org/sigrok/core/classes/Packet"));
	307	jmethodID Packet_init = env->GetMethodID(Packet, "<init>", "(JZ)V");
	308	jobject obj_ref = env->NewGlobalRef(obj);
	309
	310	$self->add_datafeed_callback([=] (
	311	std::shared_ptr<sigrok::Device> device,
	312	std::shared_ptr<sigrok::Packet> packet)
	313	{
	314	jlong device_addr;
	315	jlong packet_addr;
865de993 DE	316	device_addr = reinterpret_cast<intptr_t>(new std::shared_ptr<sigrok::Device>(device));
865de993 DE	317	packet_addr = reinterpret_cast<intptr_t>(new std::shared_ptr<sigrok::Packet>(packet));
9fcf4d0b ML	318	jobject device_obj = env->NewObject(
	319	Device, Device_init, device_addr, true);
	320	jobject packet_obj = env->NewObject(
	321	Packet, Packet_init, packet_addr, true);
	322	env->CallVoidMethod(obj_ref, method, device_obj, packet_obj);
	323	if (env->ExceptionCheck())
	324	throw sigrok::Error(SR_ERR);
	325	});
	326	}
	327	}
	328
bd4fda24	329	%include "doc.i"
062430a2	330
7a36ceac ML	331	%define %enumextras(Class)
	332	%enddef
	333
c7855def	334	/* Ignore these for now, need fixes. */
dd13d47a	335	%ignore sigrok::Context::create_analog_packet;
c7855def	336	%ignore sigrok::Context::create_meta_packet;
d0fa4ac1	337	%ignore sigrok::Meta::config;
b71356d6	338
9fcf4d0b	339	%include "bindings/swig/classes.i"
b71356d6	340