CRAN 0.2.0 release

Author: shikokuchuo

DESCRIPTION

@@ -1,12 +1,12 @@
 Package: nanonext
 Type: Package
 Title: NNG (Nanomsg Next Gen) Lightweight Messaging Library
-Version: 0.1.0.9000
+Version: 0.2.0
 Description: R binding for NNG (Nanomsg Next Gen), a successor to ZeroMQ. NNG is 
     a socket library providing high-performance scalability protocols,
-    implementing a cross-platform standard for messaging and communications. 
+    implementing a cross-platform standard for messaging and communications.
     Serves as a concurrency framework that can be used for building distributed 
-    systems.
+    applications.
 Authors@R: 
     c(person(given = "Charlie", 
              family = "Gao",
@@ -21,7 +21,8 @@ License: GPL (>= 3)
 BugReports: https://github.com/shikokuchuo/nanonext/issues
 URL: https://shikokuchuo.net/nanonext/, https://github.com/shikokuchuo/nanonext/
 Encoding: UTF-8
-SystemRequirements: either 'libnng' (deb: libnng-dev, rpm: nng-devel) or 'cmake' (to compile from source)
+SystemRequirements: either 'libnng' (deb: libnng-dev, rpm: nng-devel) 
+    or 'cmake' (to compile from source)
 Depends: 
     R (>= 2.4)
 RoxygenNote: 7.1.2

NEWS.md

@@ -1,22 +1,20 @@
-# nanonext 0.1.0.9000 (under development)
+# nanonext 0.2.0
 
 #### New Features
 
 * Implements full async I/O capabilities 
   + `send_aio()` and `recv_aio()` now return Aio objects, for which the results may be called using `call_aio()`.
-* New `request()` and `reply()` functions implement the full logic of an RPC client/server. 
+* New `request()` and `reply()` functions implement the full logic of an RPC client/server, allowing processes to run concurrently on the client and server.
   + Designed to be run in separate processes, the reply server will await data and apply a function before returning a result.
   + The request client performs an async request to the server and returns immediately with an Aio.
-  + This allows processes to run concurrently on the client and server.
 * New `ncurl()` minimalistic http(s) client.
+* New `nng_timer()` utility as a demonstration of NNG's multithreading capabilities.
 * Allows setting the environment variable 'NANONEXT_TLS' prior to package installation
   + Enables TLS where the system NNG library has been built with TLS support (using Mbed TLS).
-* New `nng_timer()` utility as a demonstration of NNG's multithreading capabilities.
 
 #### Updates
 
 * Dialer/listener starts and close operations no longer print a message to stderr when successful for less verbosity by default.
-  + The state of respective objects can always be queried using `$state`
 * All send and receive functions, e.g. `send()`/`recv()`, gain a revised 'mode' argument. 
   + This now permits R serialization as an option, consolidating the functionality of the '_vec' series of functions.
 * Functions 'send_vec' and 'recv_vec' are deprecated and will be removed in a future release.

R/nanonext-package.R

@@ -5,7 +5,8 @@
 #' R binding for NNG (Nanomsg Next Gen), a successor to ZeroMQ. NNG is a socket
 #'     library providing high-performance scalability protocols, implementing a
 #'     cross-platform standard for messaging and communications. Serves as a
-#'     concurrency framework that can be used for building distributed systems.
+#'     concurrency framework that can be used for building distributed
+#'     applications.
 #'
 #' @section Usage notes:
 #'
@@ -116,7 +117,6 @@
 #' @importFrom utils .DollarNames
 #' @useDynLib nanonext, .registration = TRUE
 #'
-#' @aliases nanonext
 #' @docType package
 #' @name nanonext-package
 #'

README.Rmd

@@ -21,11 +21,25 @@ knitr::opts_chunk$set(
 [![R-CMD-check](https://github.com/shikokuchuo/nanonext/workflows/R-CMD-check/badge.svg)](https://github.com/shikokuchuo/nanonext/actions)
 <!-- badges: end -->
 
-R binding for NNG (Nanomsg Next Gen), a successor to ZeroMQ. NNG is a socket library providing high-performance scalability protocols, implementing a cross-platform standard for messaging and communications. Serves as a concurrency framework that can be used for building distributed systems.
+R binding for NNG (Nanomsg Next Gen), a successor to ZeroMQ. NNG is a socket library providing high-performance scalability protocols, implementing a cross-platform standard for messaging and communications. Serves as a concurrency framework that can be used for building distributed applications.
 
-Designed for performance and reliability, the NNG library is written in C and {nanonext} is a lightweight wrapper depending on no other packages. Supported transports include inproc (intra-process), IPC (inter-process), TCP/IP (IPv4 or IPv6), and WebSocket. The inproc transport uses zero-copy where possible for a much faster solution than alternatives.
+Designed for performance and reliability, the NNG library is written in C and {nanonext} is a lightweight wrapper depending on no other packages. Provides the interface for code and processes to communicate with each other - receive data generated in Python, perform analysis in R, and send results to a C++ program – all on the same computer or on networks spanning the globe.
 
-Can be used for sending data across networks, but equally as an interface for code and processes to communicate with each other. Receive data generated in Python, perform analysis in R, and send results to a C++ program – all on the same computer or on networks spanning the globe.
+Implemented scalability protocols:
+
+- Bus (routing)
+- Pair (two-way radio)
+- Pipeline (one-way pipe)
+- Publisher/Subscriber (topics & broadcast)
+- Request/Reply (I ask, you answer)
+- Survey (everyone votes)
+
+Implemented transports:
+
+- inproc (intra-process)
+- IPC (inter-process)
+- TCP/IP (IPv4 or IPv6)
+- WebSocket
 
 ### Table of Contents
 
@@ -61,7 +75,8 @@ install.packages("nanonext", repos = "https://shikokuchuo.r-universe.dev")
 
 The primary object in the object-oriented interface is the nano object. Use `nano()` to create a nano object which encapsulates a Socket and Dialer/Listener. Methods such as `$send()` or `$recv()` can then be accessed directly from the object.
 
-*Example using Request/Reply (REQ/REP) protocol with inproc transport:*
+*Example using Request/Reply (REQ/REP) protocol with inproc transport:* <br />
+(The inproc transport uses zero-copy where possible for a much faster solution than alternatives)
 
 Create nano objects:
 
@@ -113,7 +128,7 @@ recv(socket2)
 
 ### Cross-language Exchange
 
-{nanonext} provides a fast and reliable data interface between different programming languages where NNG has a binding, including C, C++, Python, Go, Rust etc. 
+{nanonext} provides a fast and reliable data interface between different programming languages where NNG has a binding, including C, C++, Java, Python, Go, Rust etc. 
 
 The following example demonstrates the exchange of numerical data between R and Python (NumPy), two of the most commonly-used languages for data science and machine learning. 
 
@@ -181,7 +196,7 @@ res$result
 
 ```
 
-For a 'recvAio' object, calling the message causes it to be stored in the AIO as `$raw` and/or `$data` as the case may be.
+For a 'recvAio' object, calling the message causes it to be stored in the AIO as `$raw` (if kept) and `$data`.
 
 ```{r async3}
 
@@ -212,7 +227,7 @@ close(s2)
 
 Can be used to perform computationally-expensive calculations or I/O-bound operations such as writing large amounts of data to disk in a separate 'server' process running concurrently.
 
-Server process: `reply()` will wait for a message and apply a function, in this case `rnorm()`, before sending back the result.
+Server process: `reply()` will wait for a message and apply a function, in this case `rnorm()`, before sending back the result
 
 ```{r rpcserver, eval=FALSE}
 

README.md

@@ -16,20 +16,30 @@ R binding for NNG (Nanomsg Next Gen), a successor to ZeroMQ. NNG is a
 socket library providing high-performance scalability protocols,
 implementing a cross-platform standard for messaging and communications.
 Serves as a concurrency framework that can be used for building
-distributed systems.
+distributed applications.
 
 Designed for performance and reliability, the NNG library is written in
 C and {nanonext} is a lightweight wrapper depending on no other
-packages. Supported transports include inproc (intra-process), IPC
-(inter-process), TCP/IP (IPv4 or IPv6), and WebSocket. The inproc
-transport uses zero-copy where possible for a much faster solution than
-alternatives.
+packages. Provides the interface for code and processes to communicate
+with each other - receive data generated in Python, perform analysis in
+R, and send results to a C++ program – all on the same computer or on
+networks spanning the globe.
 
-Can be used for sending data across networks, but equally as an
-interface for code and processes to communicate with each other. Receive
-data generated in Python, perform analysis in R, and send results to a
-C++ program – all on the same computer or on networks spanning the
-globe.
+Implemented scalability protocols:
+
+-   Bus (routing)
+-   Pair (two-way radio)
+-   Pipeline (one-way pipe)
+-   Publisher/Subscriber (topics & broadcast)
+-   Request/Reply (I ask, you answer)
+-   Survey (everyone votes)
+
+Implemented transports:
+
+-   inproc (intra-process)
+-   IPC (inter-process)
+-   TCP/IP (IPv4 or IPv6)
+-   WebSocket
 
 ### Table of Contents
 
@@ -70,6 +80,8 @@ Dialer/Listener. Methods such as `$send()` or `$recv()` can then be
 accessed directly from the object.
 
 *Example using Request/Reply (REQ/REP) protocol with inproc transport:*
+<br /> (The inproc transport uses zero-copy where possible for a much
+faster solution than alternatives)
 
 Create nano objects:
 
@@ -145,8 +157,8 @@ recv(socket2)
 ### Cross-language Exchange
 
 {nanonext} provides a fast and reliable data interface between different
-programming languages where NNG has a binding, including C, C++, Python,
-Go, Rust etc.
+programming languages where NNG has a binding, including C, C++, Java,
+Python, Go, Rust etc.
 
 The following example demonstrates the exchange of numerical data
 between R and Python (NumPy), two of the most commonly-used languages
@@ -238,7 +250,7 @@ res$result
 ```
 
 For a ‘recvAio’ object, calling the message causes it to be stored in
-the AIO as `$raw` and/or `$data` as the case may be.
+the AIO as `$raw` (if kept) and `$data`.
 
 ``` r
 msg <- recv_aio(s2)
@@ -279,7 +291,7 @@ I/O-bound operations such as writing large amounts of data to disk in a
 separate ‘server’ process running concurrently.
 
 Server process: `reply()` will wait for a message and apply a function,
-in this case `rnorm()`, before sending back the result.
+in this case `rnorm()`, before sending back the result
 
 ``` r
 library(nanonext)
@@ -318,7 +330,7 @@ aio
 #> < recvAio >
 #>  - $data for message data
 str(aio$data)
-#>  num [1:100000000] -1.104 1.34 0.442 -0.738 0.66 ...
+#>  num [1:100000000] -0.69 -1.535 -0.463 0.012 0.768 ...
 ```
 
 In this example the calculation is returned, but other operations may
@@ -387,11 +399,11 @@ ncurl("http://httpbin.org/headers")
 #>   [1] 7b 0a 20 20 22 68 65 61 64 65 72 73 22 3a 20 7b 0a 20 20 20 20 22 48 6f 73
 #>  [26] 74 22 3a 20 22 68 74 74 70 62 69 6e 2e 6f 72 67 22 2c 20 0a 20 20 20 20 22
 #>  [51] 58 2d 41 6d 7a 6e 2d 54 72 61 63 65 2d 49 64 22 3a 20 22 52 6f 6f 74 3d 31
-#>  [76] 2d 36 32 30 34 30 34 66 65 2d 30 62 39 31 61 34 61 63 32 61 36 62 31 36 34
-#> [101] 31 36 61 30 32 38 30 30 63 22 0a 20 20 7d 0a 7d 0a
+#>  [76] 2d 36 32 30 34 63 34 63 34 2d 32 30 34 38 64 39 38 64 34 36 36 32 34 61 39
+#> [101] 64 33 63 32 37 33 33 36 34 22 0a 20 20 7d 0a 7d 0a
 #> 
 #> $data
-#> [1] "{\n  \"headers\": {\n    \"Host\": \"httpbin.org\", \n    \"X-Amzn-Trace-Id\": \"Root=1-620404fe-0b91a4ac2a6b16416a02800c\"\n  }\n}\n"
+#> [1] "{\n  \"headers\": {\n    \"Host\": \"httpbin.org\", \n    \"X-Amzn-Trace-Id\": \"Root=1-6204c4c4-2048d98d46624a9d3c273364\"\n  }\n}\n"
 ```
 
 [« Back to ToC](#table-of-contents)

man/nanonext-package.Rd

@@ -3,10 +3,10 @@
 if (!file.exists("../windows/rwinlib-1.5.2/include/nng.h")) {
 
   if (getRversion() < "3.3.0") setInternet2()
-  download.file("https://github.com/shikokuchuo/rwinlib/archive/refs/tags/v1.5.2.zip", destfile = "nng-latest.zip", quiet = TRUE)
+  download.file("https://github.com/shikokuchuo/rwinlib/archive/refs/tags/v1.5.2.zip", destfile = "nng-release.zip", quiet = TRUE)
   dir.create("../windows", showWarnings = FALSE)
-  unzip("nng-latest.zip", exdir = "../windows")
-  unlink("nng-latest.zip")
+  unzip("nng-release.zip", exdir = "../windows")
+  unlink("nng-release.zip")
 
 }