implements next serialisation stub

shikokuchuo · shikokuchuo · commit a34b0b0ee162 · 2023-09-26T10:25:38.000+01:00
diff --git a/DESCRIPTION b/DESCRIPTION
@@ -1,7 +1,7 @@
 Package: nanonext
 Type: Package
 Title: NNG (Nanomsg Next Gen) Lightweight Messaging Library
-Version: 0.10.0.9010
+Version: 0.10.0.9011
 Description: R binding for NNG (Nanomsg Next Gen), a successor to ZeroMQ. NNG is 
     a socket library providing high-performance scalability protocols, a
     cross-platform standard for messaging and communications. Serves as a
diff --git a/NEWS.md b/NEWS.md
@@ -1,14 +1,16 @@
-# nanonext 0.10.0.9010 (development)
+# nanonext 0.10.0.9011 (development)
 
 #### New Features
 
-* `reap()` implemented as a faster alternative to `close()` for Sockets, Contexts, Listeners and Dialers - avoiding S3 method dispatch, hence works for unclassed external pointers created by `.context()`.
 * `request()` adds logical argument 'ack', which sends an ack(nowledgement) back to the rep node upon a successful async message receive.
+* `reap()` implemented as a faster alternative to `close()` for Sockets, Contexts, Listeners and Dialers - avoiding S3 method dispatch, hence works for unclassed external pointers created by `.context()`.
+* `random()` updated to use the Mbed TLS library to generate random bytes. Adds a 'convert' argument for specifying whether to return a raw vector or character string.
+* Adds 'next' as a mode for send functions, as a 100% compatible R serialisation format.
 
 #### Updates
 
-* `random()` updated to use the Mbed TLS library to generate random bytes. Adds a 'convert' argument for specifying whether to return a raw vector or character string.
 * `write_cert()` has been optimised for higher efficiency and faster operation.
+* `send()` and `recv()` over contexts now use more efficient synchronous methods where available.
 * Fixes package installation failures where the R default C compiler command contains additional flags (thanks @potash #16).
 * Performance improvements due to simplification of the internal structure of 'aio' objects.
 * Rolls forward bundled 'libnng' to v1.6.0 alpha (a54820f).
diff --git a/R/aio.R b/R/aio.R
@@ -55,7 +55,7 @@
 #'
 #' @export
 #'
-send_aio <- function(con, data, mode = c("serial", "raw"), timeout = NULL)
+send_aio <- function(con, data, mode = c("serial", "raw", "next"), timeout = NULL)
   data <- .Call(rnng_send_aio, con, data, mode, timeout, environment())
 
 #' Receive Async
diff --git a/R/context.R b/R/context.R
@@ -101,12 +101,13 @@ close.nanoContext <- function(con, ...) invisible(.Call(rnng_ctx_close, con))
 #' @param execute a function which takes the received (converted) data as its
 #'     first argument. Can be an anonymous function of the form \code{function(x) do(x)}.
 #'     Additional arguments can also be passed in through '...'.
-#' @param send_mode [default 'serial'] to send serialised R objects, or 'raw' to
-#'     send atomic vectors of any type as a raw byte vector. Use 'serial' to
-#'     ensure perfect reproducibility within R, although 'raw' must be used when
+#' @param send_mode [default 'serial'] one of 'serial' to send serialised R objects,
+#'     'raw' to send atomic vectors of any type as a raw byte vector, or 'next'
+#'     to send in a new R-compatible serialisation format. Use 'serial' to ensure
+#'     perfect reproducibility within R, although 'raw' must be used when
 #'     interfacing with external applications which do not understand R
 #'     serialisation. Alternatively, for performance, specify an integer position
-#'     in the vector of choices i.e. 1L for 'serial' or 2L for 'raw'.
+#'     in the vector of choices e.g. 1L for 'serial' or 2L for 'raw' etc.
 #' @param recv_mode [default 'serial'] mode of vector to be received - one of
 #'     'serial', 'character', 'complex', 'double', 'integer', 'logical',
 #'     'numeric', 'raw', or 'string'. The default 'serial' means a serialised R
@@ -159,7 +160,7 @@ reply <- function(context,
                   execute,
                   recv_mode = c("serial", "character", "complex", "double",
                                 "integer", "logical", "numeric", "raw"),
-                  send_mode = c("serial", "raw"),
+                  send_mode = c("serial", "raw", "next"),
                   timeout = NULL,
                   ...) {
 
@@ -224,7 +225,7 @@ reply <- function(context,
 #'
 request <- function(context,
                     data,
-                    send_mode = c("serial", "raw"),
+                    send_mode = c("serial", "raw", "next"),
                     recv_mode = c("serial", "character", "complex", "double",
                                   "integer", "logical", "numeric", "raw", "string"),
                     timeout = NULL,
@@ -266,7 +267,7 @@ request <- function(context,
 request_signal <- function(context,
                            data,
                            cv,
-                           send_mode = c("serial", "raw"),
+                           send_mode = c("serial", "raw", "next"),
                            recv_mode = c("serial", "character", "complex", "double",
                                          "integer", "logical", "numeric", "raw", "string"),
                            timeout = NULL)
diff --git a/R/nano.R b/R/nano.R
@@ -171,19 +171,19 @@ nano <- function(protocol = c("bus", "pair", "push", "pull", "pub", "sub",
   }
 
   nano[["recv"]] <- function(mode = c("serial", "character", "complex", "double",
-                                      "integer", "logical", "numeric", "raw"),
+                                      "integer", "logical", "numeric", "raw", "string"),
                              block = NULL)
     recv(socket, mode = mode, block = block)
 
   nano[["recv_aio"]] <- function(mode = c("serial", "character", "complex", "double",
-                                          "integer", "logical", "numeric", "raw"),
+                                          "integer", "logical", "numeric", "raw", "string"),
                                  timeout = NULL)
     recv_aio(socket, mode = mode, timeout = timeout)
 
-  nano[["send"]] <- function(data, mode = c("serial", "raw"), block = NULL)
+  nano[["send"]] <- function(data, mode = c("serial", "raw", "next"), block = NULL)
     send(socket, data = data, mode = mode, block = block)
 
-  nano[["send_aio"]] <- function(data, mode = c("serial", "raw"), timeout = NULL)
+  nano[["send_aio"]] <- function(data, mode = c("serial", "raw", "next"), timeout = NULL)
     send_aio(socket, data = data, mode = mode, timeout = timeout)
 
   nano[["opt"]] <- function(name, value)
diff --git a/R/sendrecv.R b/R/sendrecv.R
@@ -22,13 +22,14 @@
 #'
 #' @param con a Socket, Context or Stream.
 #' @param data an object (a vector, if mode = 'raw').
-#' @param mode [default 'serial'] to send serialised R objects, or 'raw' to send
-#'     atomic vectors of any type as a raw byte vector. For Streams, 'raw' is
+#' @param mode [default 'serial'] one of 'serial' to send serialised R objects,
+#'     'raw' to send atomic vectors of any type as a raw byte vector, or 'next'
+#'     to send in a new R-compatible serialisation format. For Streams, 'raw' is
 #'     the only option and this argument is ignored. Use 'serial' to ensure
 #'     perfect reproducibility within R, although 'raw' must be used when
 #'     interfacing with external applications which do not understand R
 #'     serialisation. Alternatively, for performance, specify an integer position
-#'     in the vector of choices i.e. 1L for 'serial' or 2L for 'raw'.
+#'     in the vector of choices e.g. 1L for 'serial' or 2L for 'raw' etc.
 #' @param block [default NULL] which applies the connection default (see section
 #'     'Blocking' below). Specify logical TRUE to block until successful or FALSE
 #'     to return immediately even if unsuccessful (e.g. if no connection is
@@ -77,7 +78,7 @@
 #'
 #' @export
 #'
-send <- function(con, data, mode = c("serial", "raw"), block = NULL)
+send <- function(con, data, mode = c("serial", "raw", "next"), block = NULL)
   .Call(rnng_send, con, data, mode, block)
 
 #' Receive
diff --git a/man/reply.Rd b/man/reply.Rd
diff --git a/man/request.Rd b/man/request.Rd
diff --git a/man/send.Rd b/man/send.Rd
diff --git a/man/send_aio.Rd b/man/send_aio.Rd
diff --git a/src/core.c b/src/core.c
@@ -303,11 +303,12 @@ int nano_encodes(SEXP mode) {
     case 3:
       if (!strncmp(mod, "raw", slen)) return 2;
     case 4:
+      if (!strncmp(mod, "next", slen)) return 3;
     case 5:
     case 6:
       if (!strncmp(mod, "serial", slen)) return 1;
     default:
-      Rf_error("'mode' should be one of serial, raw");
+      Rf_error("'mode' should be one of serial, raw, next");
     }
   }
 
diff --git a/tests/tests.R b/tests/tests.R
@@ -75,7 +75,7 @@ nanotestz(n1$send(c("test", "", "spec"), mode = "raw", block = 500))
 nanotest(identical(n$recv("character", block = 500), c("test", "", "spec")))
 nanotestz(n1$send(c(1L, 0L, 0L), mode = "r"))
 nanotest(is.integer(n$recv("int")))
-nanotestaio(saio <- n$send_aio(data.frame(random(1e3L)), timeout = 900))
+nanotestaio(saio <- n$send_aio(data.frame(random(1e3L), mode = 3L), timeout = 900))
 nanotestp(saio)
 nanotestaio(call_aio(saio))
 nanotest(is.integer(saio$result))
@@ -225,7 +225,7 @@ nanotest(until(cv, 10L))
 nanotest(until(cv, 10))
 nanotestz(cv_reset(cv))
 nanotestz(cv_value(cv))
-nanotestaio(cs <- request_signal(req$context, "test", cv = cv, timeout = 500))
+nanotestaio(cs <- request_signal(req$context, "test", send_mode = "next", cv = cv, timeout = 500))
 nanotest(typeof(ctxn <- .context(rep)) == "externalptr")
 nanotestaio(cr <- recv_aio_signal(ctxn, cv = cv, timeout = 500))
 nanotest(call_aio(cr)$data == "test")
