docs and other cleanups

Author: shikokuchuo

NEWS.md

@@ -12,9 +12,9 @@
 * Behavioural change: messages have been upgraded to warnings across the package to allow for enhanced reporting of the originating call e.g. via `warnings()` and flexibility in handling via setting `options()`.
 * Returned NNG error codes are now all classed as 'errorValue' across the package.
 * Unified `send()` and `recv()` functions, and their asynchronous counterparts `send_aio()` and `recv_aio()`, are now S3 generics and can be used across Sockets, Contexts and Streams.
-* Revised 'block' argument for `send()` and `recv()` now allows an integer value for setting a timeout (under the hood this wraps an asynchronous send/recv followed by a wait to make it a synchronous function).
+* Revised 'block' argument for `send()` and `recv()` now allows an integer value for setting a timeout.
 * `send_ctx()` and `recv_ctx()` are deprecated and will be removed in a future package version - the methods for `send()` and `recv()` should be used instead.
-* To allow for more flexible practices, logging is now deprecated and being phased out. Logging can still be set via 'NANONEXT_LOG' prior to package load but `logging()` can no longer be used. Logging will be removed entirely in the next package version.
+* To allow for more flexible practices, logging is now deprecated and will be removed entirely in the next package version. Logging can still be enabled via 'NANONEXT_LOG' prior to package load but `logging()` is now defunct. 
 * Internal performance optimisations.
 
 # nanonext 0.3.0

R/aio.R

@@ -55,7 +55,7 @@ send_aio.nanoSocket <- function(con, data, mode = c("serial", "raw"), timeout =
   aio <- .Call(rnng_send_aio, con, data, timeout)
   is.integer(aio) && return(invisible(aio))
 
-  result <- data <- con <- NULL
+  result <- NULL
   unresolv <- TRUE
   env <- new.env(hash = FALSE)
   makeActiveBinding(sym = "result", fun = function(x) {
@@ -84,7 +84,7 @@ send_aio.nanoContext <- function(con, data, mode = c("serial", "raw"), timeout =
   aio <- .Call(rnng_ctx_send_aio, con, data, timeout)
   is.integer(aio) && return(invisible(aio))
 
-  result <- data <- con <- NULL
+  result <- NULL
   unresolv <- TRUE
   env <- new.env(hash = FALSE)
   makeActiveBinding(sym = "result", fun = function(x) {
@@ -112,7 +112,7 @@ send_aio.nanoStream <- function(con, data, mode = "raw", timeout = -2L) {
   aio <- .Call(rnng_stream_send_aio, con, data, timeout)
   is.integer(aio) && return(invisible(aio))
 
-  result <- data <- con <- NULL
+  result <- NULL
   unresolv <- TRUE
   env <- new.env(hash = FALSE)
   makeActiveBinding(sym = "result", fun = function(x) {
@@ -210,7 +210,7 @@ recv_aio.nanoSocket <- function(con,
   is.integer(aio) && return(invisible(aio))
 
   keep.raw <- missing(keep.raw) || isTRUE(keep.raw)
-  data <- raw <- con <- NULL
+  data <- raw <- NULL
   unresolv <- TRUE
   env <- new.env(hash = FALSE)
   if (keep.raw) {
@@ -286,7 +286,7 @@ recv_aio.nanoContext <- function(con,
   is.integer(aio) && return(invisible(aio))
 
   keep.raw <- missing(keep.raw) || isTRUE(keep.raw)
-  data <- raw <- con <- NULL
+  data <- raw <- NULL
   unresolv <- TRUE
   env <- new.env(hash = FALSE)
   if (keep.raw) {
@@ -363,7 +363,7 @@ recv_aio.nanoStream <- function(con,
   is.integer(aio) && return(invisible(aio))
 
   keep.raw <- missing(keep.raw) || isTRUE(keep.raw)
-  data <- raw <- con <- NULL
+  data <- raw <- NULL
   unresolv <- TRUE
   env <- new.env(hash = FALSE)
   if (keep.raw) {

R/context.R

@@ -198,7 +198,7 @@ request <- function(context,
   is.integer(aio) && return(invisible(aio))
 
   keep.raw <- missing(keep.raw) || isTRUE(keep.raw)
-  data <- raw <- context <- res <- NULL
+  data <- raw <- NULL
   unresolv <- TRUE
   env <- new.env(hash = FALSE)
   if (keep.raw) {

R/nano.R

@@ -101,7 +101,7 @@ nano <- function(protocol = c("pair", "bus", "req", "rep", "push", "pull",
                                                               keep.raw = keep.raw)
   nano[["recv_aio"]] <- function(mode = c("serial", "character", "complex", "double",
                                           "integer", "logical", "numeric", "raw"),
-                                 timeout,
+                                 timeout = -2L,
                                  keep.raw = TRUE) recv_aio.nanoSocket(socket,
                                                                       mode = mode,
                                                                       timeout = timeout,
@@ -116,10 +116,10 @@ nano <- function(protocol = c("pair", "bus", "req", "rep", "push", "pull",
                                                           echo = echo)
   nano[["send_aio"]] <- function(data,
                                  mode = c("serial", "raw"),
-                                 timeout) send_aio.nanoSocket(socket,
-                                                              data = data,
-                                                              mode = mode,
-                                                              timeout = timeout)
+                                 timeout = -2L) send_aio.nanoSocket(socket,
+                                                                    data = data,
+                                                                    mode = mode,
+                                                                    timeout = timeout)
   nano[["socket_setopt"]] <- function(type = c("bool", "int", "ms", "size",
                                                "string", "uint64"),
                                       opt,

R/sendrecv.R

@@ -32,8 +32,8 @@
 #'     For Contexts and Streams: the default behaviour is blocking with \code{block = TRUE}.
 #'     This will wait until the send has completed. Set a timeout in this case
 #'     to ensure that the function returns under all scenarios. As the underlying
-#'     implementation differs to that for Sockets, it is recommended to set a
-#'     positive integer value for \code{block} rather than FALSE.
+#'     implementation uses an asynchronous send with a wait, it is recommended
+#'     to set a positive integer value for \code{block} rather than FALSE.
 #'
 #' @examples
 #' pub <- socket("pub", dial = "inproc://nanonext")
@@ -167,8 +167,8 @@ send.nanoStream <- function(con,
 #'     For Contexts and Streams: the default behaviour is blocking with \code{block = TRUE}.
 #'     This will wait until a message is received. Set a timeout in this case to
 #'     ensure that the function returns under all scenarios. As the underlying
-#'     implementation differs to that for Sockets, it is recommended to set a
-#'     positive integer value for \code{block} rather than FALSE.
+#'     implementation uses an asynchronous send with a wait, it is recommended
+#'     to set a positive integer value for \code{block} rather than FALSE.
 #'
 #' @examples
 #' s1 <- socket("bus", listen = "inproc://nanonext")