Merge pull request #2288 from sphaero/zosc_fromstring

Create an OSC message from a string

api/python_cffi.slurp

@@ -4647,6 +4647,11 @@ zosc_t *
 zosc_t *
  zosc_frommem (char *data, size_t size);
 
+// Create a new zosc message from a string. This the same syntax as
+// zosc_create but written as a single line string.
+zosc_t *
+ zosc_fromstring (const char *oscstring);
+
 // Create a new zosc message from the given format and arguments.
 // The format type tags are as follows:
 // i - 32bit integer
@@ -4750,6 +4755,10 @@ zframe_t *
 zosc_t *
  zosc_unpack (zframe_t *frame);
 
+// Return a string describing the the OSC message. The returned string must be freed by the caller.
+char *
+ zosc_dump (zosc_t *self);
+
 // Dump OSC message to stdout, for debugging and tracing.
 void
  zosc_print (zosc_t *self);

api/zosc.api

@@ -49,6 +49,12 @@
  <argument name = "size" type = "size" />
  </constructor>
 
+ <constructor name = "fromstring" state = "draft">
+ Create a new zosc message from a string. This the same syntax as
+ zosc_create but written as a single line string.
+ <argument name = "oscstring" type = "string" />
+ </constructor>
+
  <constructor name = "create">
  Create a new zosc message from the given format and arguments.
  The format type tags are as follows:
@@ -168,6 +174,11 @@
  <return type = "zosc" fresh = "1" />
  </method>
 
+ <method name = "dump">
+ Return a string describing the the OSC message. The returned string must be freed by the caller.
+ <return type = "string" fresh="1" />
+ </method>
+
  <method name = "print">
  Dump OSC message to stdout, for debugging and tracing.
  </method>

bindings/jni/czmq-jni/src/main/c/org_zeromq_czmq_Zosc.c

@@ -37,6 +37,15 @@ Java_org_zeromq_czmq_Zosc__1_1frommem (JNIEnv *env, jclass c, jbyteArray data, j
  return frommem_;
 }
 
+JNIEXPORT jlong JNICALL
+Java_org_zeromq_czmq_Zosc__1_1fromstring (JNIEnv *env, jclass c, jstring oscstring)
+{
+ char *oscstring_ = (char *) (*env)->GetStringUTFChars (env, oscstring, NULL);
+ jlong fromstring_ = (jlong) (intptr_t) zosc_fromstring (oscstring_);
+ (*env)->ReleaseStringUTFChars (env, oscstring, oscstring_);
+ return fromstring_;
+}
+
 JNIEXPORT jlong JNICALL
 Java_org_zeromq_czmq_Zosc__1_1create (JNIEnv *env, jclass c, jstring address, jstring format)
 {
@@ -133,6 +142,15 @@ Java_org_zeromq_czmq_Zosc__1_1unpack (JNIEnv *env, jclass c, jlong frame)
  return unpack_;
 }
 
+JNIEXPORT jstring JNICALL
+Java_org_zeromq_czmq_Zosc__1_1dump (JNIEnv *env, jclass c, jlong self)
+{
+ char *dump_ = (char *) zosc_dump ((zosc_t *) (intptr_t) self);
+ jstring return_string_ = (*env)->NewStringUTF (env, dump_);
+ zstr_free (&dump_);
+ return return_string_;
+}
+
 JNIEXPORT void JNICALL
 Java_org_zeromq_czmq_Zosc__1_1print (JNIEnv *env, jclass c, jlong self)
 {

bindings/jni/czmq-jni/src/main/java/org/zeromq/czmq/Zosc.java

@@ -54,6 +54,14 @@ public static Zosc frommem (byte [] data, long size) {
  return new Zosc (__frommem (data, size));
  }
  /*
+ Create a new zosc message from a string. This the same syntax as
+ zosc_create but written as a single line string.
+ */
+ native static long __fromstring (String oscstring);
+ public static Zosc fromstring (String oscstring) {
+ return new Zosc (__fromstring (oscstring));
+ }
+ /*
  Create a new zosc message from the given format and arguments.
  The format type tags are as follows:
  i - 32bit integer
@@ -195,6 +203,13 @@ public static Zosc unpack (Zframe frame) {
  return new Zosc (__unpack (frame.self));
  }
  /*
+ Return a string describing the the OSC message. The returned string must be freed by the caller.
+ */
+ native static String __dump (long self);
+ public String dump () {
+ return __dump (self);
+ }
+ /*
  Dump OSC message to stdout, for debugging and tracing.
  */
  native static void __print (long self);

bindings/lua_ffi/czmq_ffi.lua

@@ -4642,6 +4642,11 @@ zosc_t *
 zosc_t *
  zosc_frommem (char *data, size_t size);
 
+// Create a new zosc message from a string. This the same syntax as
+// zosc_create but written as a single line string.
+zosc_t *
+ zosc_fromstring (const char *oscstring);
+
 // Create a new zosc message from the given format and arguments.
 // The format type tags are as follows:
 // i - 32bit integer
@@ -4745,6 +4750,10 @@ zframe_t *
 zosc_t *
  zosc_unpack (zframe_t *frame);
 
+// Return a string describing the the OSC message. The returned string must be freed by the caller.
+char *
+ zosc_dump (zosc_t *self);
+
 // Dump OSC message to stdout, for debugging and tracing.
 void
  zosc_print (zosc_t *self);

bindings/nodejs/README.md

@@ -5208,6 +5208,12 @@ zosc my_zosc.unpack (Zframe)
 
 Transform a zframe into a zosc.
 
+```
+string my_zosc.dump ()
+```
+
+Return a string describing the the OSC message. The returned string must be freed by the caller.
+
 ```
 nothing my_zosc.print ()
 ```

bindings/nodejs/binding.cc

@@ -9679,6 +9679,7 @@ NAN_MODULE_INIT (Zosc::Init) {
  Nan::SetPrototypeMethod (tpl, "pack", _pack);
  Nan::SetPrototypeMethod (tpl, "packx", _packx);
  Nan::SetPrototypeMethod (tpl, "unpack", _unpack);
+ Nan::SetPrototypeMethod (tpl, "dump", _dump);
  Nan::SetPrototypeMethod (tpl, "print", _print);
  Nan::SetPrototypeMethod (tpl, "popInt32", _pop_int32);
  Nan::SetPrototypeMethod (tpl, "popInt64", _pop_int64);
@@ -9840,6 +9841,12 @@ NAN_METHOD (Zosc::_unpack) {
  }
 }
 
+NAN_METHOD (Zosc::_dump) {
+ Zosc *zosc = Nan::ObjectWrap::Unwrap <Zosc> (info.Holder ());
+ char *result = (char *) zosc_dump (zosc->self);
+ info.GetReturnValue ().Set (Nan::New (result).ToLocalChecked ());
+}
+
 NAN_METHOD (Zosc::_print) {
  Zosc *zosc = Nan::ObjectWrap::Unwrap <Zosc> (info.Holder ());
  zosc_print (zosc->self);

bindings/nodejs/binding.h

@@ -1130,6 +1130,7 @@ class Zosc: public Nan::ObjectWrap {
  static NAN_METHOD (_pack);
  static NAN_METHOD (_packx);
  static NAN_METHOD (_unpack);
+ static NAN_METHOD (_dump);
  static NAN_METHOD (_print);
  static NAN_METHOD (_pop_int32);
  static NAN_METHOD (_pop_int64);

bindings/python/czmq/_czmq_ctypes.py

@@ -9559,6 +9559,8 @@ def test(verbose):
 lib.zosc_fromframe.argtypes = [zframe_p]
 lib.zosc_frommem.restype = zosc_p
 lib.zosc_frommem.argtypes = [c_void_p, c_size_t]
+lib.zosc_fromstring.restype = zosc_p
+lib.zosc_fromstring.argtypes = [c_char_p]
 lib.zosc_create.restype = zosc_p
 lib.zosc_create.argtypes = [c_char_p, c_char_p]
 lib.zosc_size.restype = c_size_t
@@ -9581,6 +9583,8 @@ def test(verbose):
 lib.zosc_packx.argtypes = [POINTER(zosc_p)]
 lib.zosc_unpack.restype = zosc_p
 lib.zosc_unpack.argtypes = [zframe_p]
+lib.zosc_dump.restype = POINTER(c_char)
+lib.zosc_dump.argtypes = [zosc_p]
 lib.zosc_print.restype = None
 lib.zosc_print.argtypes = [zosc_p]
 lib.zosc_is.restype = c_bool
@@ -9695,6 +9699,14 @@ def frommem(data, size):
  """
  return Zosc(lib.zosc_frommem(data, size), True)
 
+ @staticmethod
+ def fromstring(oscstring):
+ """
+ Create a new zosc message from a string. This the same syntax as
+zosc_create but written as a single line string.
+ """
+ return Zosc(lib.zosc_fromstring(oscstring), True)
+
  @staticmethod
  def create(address, format, *args):
  """
@@ -9819,6 +9831,12 @@ def unpack(frame):
  """
  return Zosc(lib.zosc_unpack(frame), True)
 
+ def dump(self):
+ """
+ Return a string describing the the OSC message. The returned string must be freed by the caller.
+ """
+ return return_fresh_string(lib.zosc_dump(self._as_parameter_))
+
  def print(self):
  """
  Dump OSC message to stdout, for debugging and tracing.

bindings/python_cffi/czmq_cffi/Zosc.py

@@ -61,6 +61,14 @@ def frommem(data, size):
  """
  return utils.lib.zosc_frommem(data, size)
 
+ @staticmethod
+ def fromstring(oscstring):
+ """
+ Create a new zosc message from a string. This the same syntax as
+ zosc_create but written as a single line string.
+ """
+ return utils.lib.zosc_fromstring(utils.to_bytes(oscstring))
+
  @staticmethod
  def create(address, format, *format_args):
  """
@@ -185,6 +193,12 @@ def unpack(frame):
  """
  return utils.lib.zosc_unpack(frame._p)
 
+ def dump(self):
+ """
+ Return a string describing the the OSC message. The returned string must be freed by the caller.
+ """
+ return utils.lib.zosc_dump(self._p)
+
  def print_py(self):
  """
  Dump OSC message to stdout, for debugging and tracing.

bindings/python_cffi/czmq_cffi/cdefs.py

@@ -4649,6 +4649,11 @@
 zosc_t *
  zosc_frommem (char *data, size_t size);
 
+// Create a new zosc message from a string. This the same syntax as
+// zosc_create but written as a single line string.
+zosc_t *
+ zosc_fromstring (const char *oscstring);
+
 // Create a new zosc message from the given format and arguments.
 // The format type tags are as follows:
 // i - 32bit integer
@@ -4752,6 +4757,10 @@
 zosc_t *
  zosc_unpack (zframe_t *frame);
 
+// Return a string describing the the OSC message. The returned string must be freed by the caller.
+char *
+ zosc_dump (zosc_t *self);
+
 // Dump OSC message to stdout, for debugging and tracing.
 void
  zosc_print (zosc_t *self);

bindings/qml/src/QmlZosc.cpp

@@ -99,6 +99,15 @@ QmlZframe *QmlZosc::pack () {
  return retQ_;
 };
 
+///
+// Return a string describing the the OSC message. The returned string must be freed by the caller.
+QString QmlZosc::dump () {
+ char *retStr_ = zosc_dump (self);
+ QString retQStr_ = QString (retStr_);
+ free (retStr_);
+ return retQStr_;
+};
+
 ///
 // Dump OSC message to stdout, for debugging and tracing.
 void QmlZosc::print () {
@@ -254,6 +263,15 @@ QmlZosc *QmlZoscAttached::frommem (char *data, size_t size) {
  return qmlSelf;
 };
 
+///
+// Create a new zosc message from a string. This the same syntax as
+// zosc_create but written as a single line string.
+QmlZosc *QmlZoscAttached::fromstring (const QString &oscstring) {
+ QmlZosc *qmlSelf = new QmlZosc ();
+ qmlSelf->self = zosc_fromstring (oscstring.toUtf8().data());
+ return qmlSelf;
+};
+
 ///
 // Create a new zosc message from the given format and arguments.
 // The format type tags are as follows:

bindings/qml/src/QmlZosc.h

@@ -91,6 +91,9 @@ public slots:
  // Transform zosc into a zframe that can be sent in a message.
  QmlZframe *pack ();
 
+ // Return a string describing the the OSC message. The returned string must be freed by the caller.
+ QString dump ();
+
  // Dump OSC message to stdout, for debugging and tracing.
  void print ();
 
@@ -185,6 +188,10 @@ public slots:
  // and calling free on the data after construction.
  QmlZosc *frommem (char *data, size_t size);
 
+ // Create a new zosc message from a string. This the same syntax as
+ // zosc_create but written as a single line string.
+ QmlZosc *fromstring (const QString &oscstring);
+
  // Create a new zosc message from the given format and arguments.
  // The format type tags are as follows:
  // i - 32bit integer

bindings/qt/src/qzosc.cpp

@@ -38,6 +38,14 @@ QZosc* QZosc::frommem (char *data, size_t size, QObject *qObjParent)
  return new QZosc (zosc_frommem (data, size), qObjParent);
 }
 
+///
+// Create a new zosc message from a string. This the same syntax as
+// zosc_create but written as a single line string.
+QZosc* QZosc::fromstring (const QString &oscstring, QObject *qObjParent)
+{
+ return new QZosc (zosc_fromstring (oscstring.toUtf8().data()), qObjParent);
+}
+
 ///
 // Destroy an OSC message
 QZosc::~QZosc ()
@@ -126,6 +134,16 @@ QZosc * QZosc::unpack (QZframe *frame)
  return rv;
 }
 
+///
+// Return a string describing the the OSC message. The returned string must be freed by the caller.
+QString QZosc::dump ()
+{
+ char *retStr_ = zosc_dump (self);
+ QString rv = QString (retStr_);
+ zstr_free (&retStr_);
+ return rv;
+}
+
 ///
 // Dump OSC message to stdout, for debugging and tracing.
 void QZosc::print ()

bindings/qt/src/qzosc.h

@@ -28,6 +28,10 @@ class QT_CZMQ_EXPORT QZosc : public QObject
  // and calling free on the data after construction.
  static QZosc* frommem (char *data, size_t size, QObject *qObjParent = 0);
 
+ // Create a new zosc message from a string. This the same syntax as
+ // zosc_create but written as a single line string.
+ static QZosc* fromstring (const QString &oscstring, QObject *qObjParent = 0);
+
  // Destroy an OSC message
  ~QZosc ();
 
@@ -72,6 +76,9 @@ class QT_CZMQ_EXPORT QZosc : public QObject
  // Transform a zframe into a zosc.
  static QZosc * unpack (QZframe *frame);
 
+ // Return a string describing the the OSC message. The returned string must be freed by the caller.
+ QString dump ();
+
  // Dump OSC message to stdout, for debugging and tracing.
  void print ();
 

bindings/ruby/lib/czmq/ffi.rb

@@ -989,6 +989,7 @@ def self.attach_function(name, *rest)
  attach_function :zosc_new, [:string], :pointer, **opts
  attach_function :zosc_fromframe, [:pointer], :pointer, **opts
  attach_function :zosc_frommem, [:pointer, :size_t], :pointer, **opts
+ attach_function :zosc_fromstring, [:string], :pointer, **opts
  attach_function :zosc_create, [:string, :string, :varargs], :pointer, **opts
  attach_function :zosc_destroy, [:pointer], :void, **opts
  attach_function :zosc_size, [:pointer], :size_t, **opts
@@ -1001,6 +1002,7 @@ def self.attach_function(name, *rest)
  attach_function :zosc_pack, [:pointer], :pointer, **opts
  attach_function :zosc_packx, [:pointer], :pointer, **opts
  attach_function :zosc_unpack, [:pointer], :pointer, **opts
+ attach_function :zosc_dump, [:pointer], :pointer, **opts
  attach_function :zosc_print, [:pointer], :void, **opts
  attach_function :zosc_is, [:pointer], :bool, **opts
  attach_function :zosc_first, [:pointer, :pointer], :pointer, **opts