non-erroring rawToChar; removes recover_aio()

Author: shikokuchuo

DESCRIPTION

@@ -1,7 +1,7 @@
 Package: nanonext
 Type: Package
 Title: NNG (Nanomsg Next Gen) Lightweight Messaging Library
-Version: 0.9.2.9033
+Version: 0.9.2.9034
 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

NAMESPACE

@@ -65,7 +65,6 @@ export(opt)
 export(parse_url)
 export(pipe_notify)
 export(random)
-export(recover_aio)
 export(recv)
 export(recv_aio)
 export(recv_aio_signal)

NEWS.md

@@ -1,9 +1,8 @@
-# nanonext 0.9.2.9033 (development)
+# nanonext 0.9.2.9034 (development)
 
 #### New Features
 
 * `ncurl_aio()` has been separated into a dedicated function for async http requests.
-* `recover_aio()` allows recovery of 'ncurlAio' where character conversion fails.
 * Receive functions add `mode = 'string'` as a faster alternative to 'character' when receiving a scalar value.
 
 #### Updates
@@ -18,8 +17,8 @@
 
 *Other changes:*
 
-* Improvements to recv (mode = 'serial'):
-  + Failure to unserialize a message will automatically save the data as a raw vector for recovery, and generate a warning (as was the case prior to v0.9.2).
+* Improvements to recv (mode = 'serial') and `ncurl()`:
+  + Failure to unserialize, or convert to character, automatically saves the data as a raw vector for recovery, generating a warning instead of an error (as was the case prior to v0.9.2).
 * Improvements to vector send/recv (mode = 'raw'):
   + Higher performance sending of vector data.
   + Permits sending of NULL, in which case an empty vector of the corresponding mode is received.

R/aio.R

@@ -290,28 +290,3 @@ unresolved <- function(aio) .Call(rnng_unresolved, aio)
 #' @export
 #'
 .unresolved <- function(aio) .Call(rnng_unresolved2, aio)
-
-#' Recover an Aio Value
-#'
-#' For use on 'ncurlAio' when encountering a character conversion error
-#'     'embedded nul in string' (received data is not text data). This function
-#'     allows recovery by retrieving the value as a raw vector.
-#'
-#' @param aio an ncurlAio (object of class 'ncurlAio').
-#'
-#' @return The passed object (invisibly).
-#'
-#' @details A raw vector will be available at \code{$data}, as if
-#'     \code{convert = FALSE} had been specified.
-#'
-#'     Note: calling this function on an unresolved Aio is an error and any
-#'     resulting operation is not guaranteed.
-#'
-#' @examples
-#' res <- ncurl_aio("https://shikokuchuo.net/nanonext/reference/figures/logo.png")
-#' tryCatch(call_aio(res), error = identity)
-#' recover_aio(res)$data
-#'
-#' @export
-#'
-recover_aio <- function(aio) invisible(.Call(rnng_aio_recover, aio))

man/recover_aio.Rd

@@ -743,55 +743,6 @@ SEXP rnng_aio_call(SEXP aio) {
 
 }
 
-SEXP rnng_aio_recover(SEXP aio) {
-
-  if (TYPEOF(aio) != ENVSXP)
-    return aio;
-
-  const SEXP coreaio = Rf_findVarInFrame(aio, nano_AioSymbol);
-  if (R_ExternalPtrTag(coreaio) != nano_AioSymbol)
-    return aio;
-
-  nano_aio *raio = (nano_aio *) R_ExternalPtrAddr(coreaio);
-  if (raio->data == NULL) return aio;
-
-  SEXP out;
-  const int mod = 8;
-  unsigned char *buf;
-  size_t sz;
-
-  switch (raio->type) {
-  case IOV_RECVAIO:
-    buf = raio->data;
-    sz = nng_aio_count(raio->aio);
-    break;
-  case RECVAIO: ;
-    nng_msg *msg = (nng_msg *) raio->data;
-    buf = nng_msg_body(msg);
-    sz = nng_msg_len(msg);
-    break;
-  case HTTP_AIO: ;
-    nano_handle *handle = (nano_handle *) raio->data;
-    nng_http_res_get_data(handle->res, (void **) &buf, &sz);
-    out = Rf_allocVector(RAWSXP, sz);
-    if (buf != NULL)
-      memcpy(STDVEC_DATAPTR(out), buf, sz);
-    Rf_defineVar(nano_ResultSymbol, out, ENCLOS(aio));
-    Rf_defineVar(nano_AioSymbol, R_NilValue, aio);
-    return aio;
-  default:
-    return aio;
-  }
-
-  PROTECT(out = nano_decode(buf, sz, mod));
-  Rf_defineVar(nano_ResultSymbol, out, ENCLOS(aio));
-  Rf_defineVar(nano_AioSymbol, R_NilValue, aio);
-
-  UNPROTECT(1);
-  return aio;
-
-}
-
 SEXP rnng_aio_stop(SEXP aio) {
 
   if (TYPEOF(aio) != ENVSXP)

src/aio.c

@@ -110,11 +110,17 @@ static SEXP rawOneString(unsigned char *bytes, R_xlen_t nbytes, R_xlen_t *np) {
 SEXP rawToChar(unsigned char *buf, const size_t sz) {
 
   SEXP out;
-  int i, j;
-  for (i = 0, j = -1; i < sz; i++) if (buf[i]) j = i;
+  const char *cbuf = (const char *) buf;
+  size_t slen = strnlen(cbuf, sz);
+  if (sz - slen > 1) {
+    Rf_warning("data could not be converted to a character string");
+    out = Rf_allocVector(RAWSXP, sz);
+    memcpy(STDVEC_DATAPTR(out), buf, sz);
+    return out;
+  }
 
   PROTECT(out = Rf_allocVector(STRSXP, 1));
-  SET_STRING_ELT(out, 0, Rf_mkCharLenCE((const char *) buf, j + 1, CE_NATIVE));
+  SET_STRING_ELT(out, 0, Rf_mkCharLenCE(cbuf, slen, CE_NATIVE));
 
   UNPROTECT(1);
   return out;

src/core.c

@@ -126,7 +126,6 @@ static const R_CallMethodDef callMethods[] = {
   {"rnng_aio_get_msg", (DL_FUNC) &rnng_aio_get_msg, 1},
   {"rnng_aio_get_msg2", (DL_FUNC) &rnng_aio_get_msg2, 1},
   {"rnng_aio_http", (DL_FUNC) &rnng_aio_http, 3},
-  {"rnng_aio_recover", (DL_FUNC) &rnng_aio_recover, 1},
   {"rnng_aio_result", (DL_FUNC) &rnng_aio_result, 1},
   {"rnng_aio_stop", (DL_FUNC) &rnng_aio_stop, 1},
   {"rnng_clock", (DL_FUNC) &rnng_clock, 0},

src/init.c

@@ -221,7 +221,6 @@ extern SEXP rnng_aio_call(SEXP);
 extern SEXP rnng_aio_get_msg(SEXP);
 extern SEXP rnng_aio_get_msg2(SEXP);
 extern SEXP rnng_aio_http(SEXP, SEXP, SEXP);
-extern SEXP rnng_aio_recover(SEXP);
 extern SEXP rnng_aio_result(SEXP);
 extern SEXP rnng_aio_stop(SEXP);
 extern SEXP rnng_base64dec(SEXP, SEXP);

src/nanonext.h

@@ -334,8 +334,7 @@ haio <- ncurl_aio("https://i.i")
 nanotest(is_error_value(call_aio(haio)$data))
 nanotestp(haio$data)
 ncaio <- ncurl_aio("https://shikokuchuo.net/nanonext/reference/figures/logo.png")
-nanotest(is_error_value(tryCatch(call_aio(ncaio)$status, error = function(e) `class<-`("", "errorValue"))))
-nanotest(is.raw(recover_aio(ncaio)$data) || is_error_value(ncaio$data))
+nanotestw(is.raw(call_aio(ncaio)$data) || is_error_value(ncaio$data))
 sess <- ncurl_session("https://postman-echo.com/post", method = "POST", headers = c(`Content-Type` = "text/plain"), data = "test", response = "server", timeout = 3000L)
 nanotestnn(sess)
 nanotest(is_error_value(sess) || length(transact(sess)) == 3L)
@@ -439,7 +438,6 @@ nanotesterr(.context(fakesock), "valid Socket")
 nanotesterr(stat(fakesock, "pipes"), "valid Socket")
 nanotesterr(close(fakesock), "valid Socket")
 nanotest(!.unresolved(fakesock))
-nanotest(identical(recover_aio(fakesock), fakesock))
 fakectx <- `class<-`("test", "nanoContext")
 nanotest(!.unresolved(fakectx))
 nanotesterr(request(fakectx, data = "test"), "valid Context")
@@ -468,7 +466,6 @@ unres <- as.symbol(" unresolvedValue ")
 nanotest(unresolved(unres))
 nanotest(!unresolved("unresolvedValue"))
 nanotest(identical(call_aio("a"), "a"))
-nanotest(identical(recover_aio("a"), "a"))
 nanotestn(stop_aio("a"))
 
 nanotest(sha256("test") == "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08")