X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=bindings%2Fjava%2Forg%2Fsigrok%2Fcore%2Fclasses%2Fclasses.i;h=daa66305a37e527d0eca6ee3051b6350d9e0ec58;hb=f2831ab35b4988930535dfd135884873b1b5b00d;hp=52eace85a7acfc7ed778b6fe07a8d3bf821dcd19;hpb=7a958e2a0703ba1ddc4c27a3f597efe1873eec69;p=libsigrok.git diff --git a/bindings/java/org/sigrok/core/classes/classes.i b/bindings/java/org/sigrok/core/classes/classes.i index 52eace85..daa66305 100644 --- a/bindings/java/org/sigrok/core/classes/classes.i +++ b/bindings/java/org/sigrok/core/classes/classes.i @@ -7,31 +7,45 @@ } %} -/* Import interfaces. */ +/* Documentation & importing interfaces. */ %pragma(java) jniclassimports=%{ - import org.sigrok.core.interfaces.LogCallback; - import org.sigrok.core.interfaces.DatafeedCallback; - import org.sigrok.core.interfaces.SourceCallback; +/** + * @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 Java FileDescriptor objects to int fds */ -%typemap(jni) int fd "jobject" -%typemap(jtype) int fd "java.io.FileDescriptor" -%typemap(jstype) int fd "java.io.FileDescriptor" -%typemap(javain) int fd "$javainput" - -%typemap(in) int fd { - jclass FileDescriptor = jenv->FindClass("java/io/FileDescriptor"); - jfieldID fd = jenv->GetFieldID(FileDescriptor, "fd", "I"); - $1 = jenv->GetIntField($input, fd); -} - /* 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) @@ -40,20 +54,12 @@ namespace Glib { %typemap(jstype) std::vector< CValue > "java.util.Vector" %typemap(javain, - pre=" $javaclassname temp$javainput = $javaclassname.convertVector($javainput);", + 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(javacode) std::vector< CValue > %{ - static $javaclassname convertVector(java.util.Vector in) - { - $javaclassname out = new $javaclassname(); - for (JValue value : in) - out.add(value); - return out; - } -%} - %typemap(javaout) std::vector< CValue > { return (java.util.Vector)$jnicall; } @@ -88,20 +94,12 @@ VECTOR(std::shared_ptr, HardwareDevice) "java.util.Map" %typemap(javain, - pre=" $javaclassname temp$javainput = $javaclassname.convertMap($javainput);", + pre=" $javaclassname temp$javainput = new $javaclassname(); + for (java.util.Map.Entry entry : $javainput.entrySet()) + temp$javainput.set(entry.getKey(), entry.getValue());", pgcppname="temp$javainput") std::map< CKey, CValue > "$javaclassname.getCPtr(temp$javainput)" -%typemap(javacode) std::map< CKey, CValue > %{ - static $javaclassname convertMap(java.util.Map in) - { - $javaclassname out = new $javaclassname(); - for (java.util.Map.Entry entry : in.entrySet()) - out.set(entry.getKey(), entry.getValue()); - return out; - } -%} - %typemap(javaout) std::map< CKey, CValue > { return (java.util.Map)$jnicall; } @@ -112,6 +110,11 @@ VECTOR(std::shared_ptr, HardwareDevice) MAP_COMMON(std::string, std::string, String, String) +%typemap(jni) std::map + "jobject" +%typemap(jtype) std::map + "java.util.Map" + %typemap(out) std::map { jclass HashMap = jenv->FindClass("java/util/HashMap"); jmethodID init = jenv->GetMethodID(HashMap, "", "()V"); @@ -190,22 +193,41 @@ MAP_COMMON(const sigrok::ConfigKey *, Glib::VariantBase, ConfigKey, Variant) } } -/* Support Driver.scan() with no arguments. */ -%extend sigrok::Driver { - std::vector > scan() - { - std::map options; - return $self->scan(options); - } -} +/* Specialisation for ConfigKey->set maps */ + +MAP_COMMON(const sigrok::ConfigKey *, std::set, + ConfigKey, java.util.Set) -/* Support OutputFormat.create_output(device) with no options. */ -%extend sigrok::OutputFormat { - std::shared_ptr create_output( - std::shared_ptr device) +%typemap(jni) std::map> "jobject" +%typemap(jtype) std::map> + "java.util.Map>" + +%typemap(out) std::map> { + jclass HashMap = jenv->FindClass("java/util/HashMap"); + jmethodID HashMap_init = jenv->GetMethodID(HashMap, "", "()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, "", "()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, "", "(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) { - std::map options; - return $self->create_output(device, options); + *(const sigrok::ConfigKey **) &key = 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); } } @@ -307,42 +329,15 @@ typedef jobject jdatafeedcallback; } } -/* Support Java event source callbacks. */ - -%typemap(javaimports) sigrok::EventSource - "import org.sigrok.core.interfaces.SourceCallback;" - -%inline { -typedef jobject jsourcecallback; -} - -%typemap(jni) jsourcecallback "jsourcecallback" -%typemap(jtype) jsourcecallback "SourceCallback" -%typemap(jstype) jsourcecallback "SourceCallback" -%typemap(javain) jsourcecallback "$javainput" +%include "doc.i" -%extend sigrok::EventSource -{ - std::shared_ptr create( - int fd, Glib::IOCondition events, int timeout, - JNIEnv *env, jsourcecallback obj) - { - (void) $self; - jclass obj_class = env->GetObjectClass(obj); - jmethodID method = env->GetMethodID(obj_class, "run", "(I)V"); - jobject obj_ref = env->NewGlobalRef(obj); - - return sigrok::EventSource::create(fd, events, timeout, [=] (int revents) - { - bool result = env->CallBooleanMethod(obj_ref, method, revents); - if (env->ExceptionCheck()) - throw sigrok::Error(SR_ERR); - return result; - }); - } -} +%define %enumextras(Class) +%enddef -/* Currently broken due to some std::map typemap issues. */ -%ignore sigrok::Meta::get_config; +/* 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" +