Context functions converted.

11 files changed, 569 insertions, 0 deletions

diff --git a/docs/ref/ctx/nng_ctx_close.adoc b/docs/ref/ctx/nng_ctx_close.adoc
new file mode 100644
index 00000000..9e93db31
--- /dev/null
+++ b/docs/ref/ctx/nng_ctx_close.adoc
@@ -0,0 +1,35 @@
+## nng_ctx_close
+
+Close context.
+
+### Synopsis
+
+```c
+#include <nng/nng.h>
+
+int nng_ctx_close(nng_ctx ctx);
+```
+
+### Description
+
+The `nng_ctx_close` function closes the context _ctx_.
+Messages that have been submitted for sending may be flushed or delivered, depending upon the transport.
+
+Further attempts to use the context after this call returns will result in `NNG_ECLOSED`.
+Threads waiting for operations on the context when this call is executed may also return with an `NNG_ECLOSED` result.
+
+TIP: Closing the socket associated with _ctx_ also closes this context.
+
+### Return Values
+
+This function returns 0 on success, and non-zero otherwise.
+
+### Errors
+
+[horizontal]
+`NNG_ECLOSED`:: The context _ctx_ is already closed or was never opened.
+
+### See Also
+
+xref:../sock/nng_close.adoc[nng_close],
+xref:nng_ctx_open.adoc[nng_ctx_open]
diff --git a/docs/ref/ctx/nng_ctx_get.adoc b/docs/ref/ctx/nng_ctx_get.adoc
new file mode 100644
index 00000000..4df686bb
--- /dev/null
+++ b/docs/ref/ctx/nng_ctx_get.adoc
@@ -0,0 +1,102 @@
+## nng_ctx_get
+
+Get context option.
+
+### Synopsis
+
+```c
+#include <nng/nng.h>
+
+int nng_ctx_get(nng_ctx ctx, const char *opt, void *val, size_t *valszp);
+
+int nng_ctx_get_bool(nng_ctx ctx, const char *opt, bool *bvalp);
+
+int nng_ctx_get_int(nng_ctx ctx, const char *opt, int *ivalp);
+
+int nng_ctx_get_ms(nng_ctx ctx, const char *opt, nng_duration *durp);
+
+int nng_ctx_get_size(nng_ctx ctx, const char *opt, size_t *zp);
+
+int nng_ctx_get_string(nng_ctx ctx, const char *opt, char **strp);
+
+int nng_ctx_get_uint64(nng_ctx ctx, const char *opt, uint64_t *u64p);
+
+```
+
+### Description
+
+(((options, context)))
+The `nng_ctx_get` functions are used to retrieve option values for the xref:nng_ctx.adoc[context] _ctx_.
+The actual options that may be retrieved in this way vary.
+A number of them are documented in xref:nng_options.adoc[nng_options].
+
+NOTE: Context options are protocol specific.
+The details will be documented with the protocol.
+
+#### Forms
+
+In all of these forms, the option _opt_ is retrieved from the context _ctx_.
+The forms vary based on the type of the option they take.
+
+The details of the type, size, and semantics of the option will depend on the actual option.
+See the documentation for the option itself for more information.
+
+`nng_ctx_get`::
+This function is untyped and can be used to retrieve the value of any option.
+The caller supplies a buffer to receive the value in _val_, and the size of that buffer in _valszp_. +
+ +
+When the function returns, the actual size of the data copied (or that would have been copied if sufficient space were present) is return in the location referenced by _valszp_.
+If the caller's buffer is not large enough to hold the entire object, then the copy is truncated.
+Therefore the caller should check for truncation by verifying that the returned size in _valszp_ does not exceed the original buffer size. +
+ +
+It is acceptable to pass `NULL` for _val_ if the value in _valszp_ is zero.
+This can be used to determine the size of the buffer needed to receive the object.
+
+TIP: It may be easier to use one of the typed forms of this function.
+
+`nng_ctx_get_bool`::
+This retrieves a Boolean (`bool`) into _bvalp_.
+
+`nng_ctx_get_int`::
+This function retrieves an integer (`int`) into _ivalp_.
+
+`nng_ctx_get_ms`::
+This function retrieves a time xref:nng_duration.adoc[duration] (in milliseconds) into _durp_.
+(The special value ((`NNG_DURATION_INFINITE`)) means an infinite amount of time, and
+the special value ((`NNG_DURATION_DEFAULT`)) means a context-specific default.)
+
+`nng_ctx_get_size`::
+This function retrieves a size into _zp_.
+This is typically used for buffer sizes, maximum sizes, and similar options.
+
+`nng_ctx_get_string`::
+This retrieves a string into _strp_.
+This string is created from the source using xref:nng_strdup.adoc[`nng_strdup`]
+and consequently must be freed by the caller using
+xref:nng_strfree.adoc[`nng_strfree`] when it is no longer needed.
+
+`nng_ctx_get_uint64`::
+This function is used to retrieve a 64-bit unsigned value into the value
+referenced by _u64p_.
+
+### Return Values
+
+These functions return 0 on success, and non-zero otherwise.
+
+### Errors
+
+[horizontal]
+`NNG_EBADTYPE`:: Incorrect type for option.
+`NNG_ECLOSED`:: Parameter _s_ does not refer to an open socket.
+`NNG_EINVAL`:: Size of destination _val_ too small for object.
+`NNG_ENOMEM`:: Insufficient memory exists.
+`NNG_ENOTSUP`:: The option _opt_ is not supported.
+`NNG_EWRITEONLY`:: The option _opt_ is write-only.
+
+### See Also
+
+xref:../opts/index.adoc[Options],
+xref:nng_ctx_set.adoc[nng_ctx_set],
+xref:../util/nng_strdup.adoc[nng_strdup],
+xref:../util/nng_strfree.adoc[nng_strfree],
+xref:nng_options.adoc[nng_options]
diff --git a/docs/ref/ctx/nng_ctx_getopt.adoc b/docs/ref/ctx/nng_ctx_getopt.adoc
new file mode 100644
index 00000000..cd9dfd53
--- /dev/null
+++ b/docs/ref/ctx/nng_ctx_getopt.adoc
@@ -0,0 +1,43 @@
+## nng_ctx_getopt
+
+Get context option (deprecated).
+
+### Synopsis
+
+```c
+#include <nng/nng.h>
+
+int nng_ctx_getopt(nng_ctx ctx, const char *opt, void *val, size_t *valszp);
+int nng_ctx_getopt_bool(nng_ctx ctx, const char *opt, bool *bvalp);
+int nng_ctx_getopt_int(nng_ctx ctx, const char *opt, int *ivalp);
+int nng_ctx_getopt_ms(nng_ctx ctx, const char *opt, nng_duration *durp);
+int nng_ctx_getopt_size(nng_ctx ctx, const char *opt, size_t *zp);
+int nng_ctx_getopt_string(nng_ctx ctx, const char *opt, char **strp);
+int nng_ctx_getopt_uint64(nng_ctx ctx, const char *opt, uint64_t *u64p);
+```
+
+### Description
+
+NOTE: These functions are deprecated.
+They may not be present if the library was built with ((`NNG_ELIDE_DEPRECATED`)).
+
+These deprecated functions have one-to-one modern equivalents with the same arguments and semantics, as follows:
+
+[width=50%,]
+|===
+| Legacy Function | Modern Equivalent
+
+| `nng_ctx_getopt` | `nng_ctx_set`
+| `nng_ctx_getopt_bool`| `nng_ctx_get_bool`
+| `nng_ctx_getopt_int`| `nng_ctx_get_int`
+| `nng_ctx_getopt_ms`| `nng_ctx_get_ms`
+| `nng_ctx_getopt_size`| `nng_ctx_get_size`
+| `nng_ctx_getopt_string`| `nng_ctx_get_string`
+| `nng_ctx_getopt_uint64`| `nng_ctx_get_uint64`
+|===
+
+Please see the documentation for the modern equivalents for more detail.
+
+### See Also
+
+xref:../ctx/nng_ctx_get.adoc[nng_ctx_get]
diff --git a/docs/ref/ctx/nng_ctx_id.adoc b/docs/ref/ctx/nng_ctx_id.adoc
new file mode 100644
index 00000000..ebd05213
--- /dev/null
+++ b/docs/ref/ctx/nng_ctx_id.adoc
@@ -0,0 +1,29 @@
+## nng_ctx_id
+
+Return numeric context identifier.
+
+### Synopsis
+
+```c
+#include <nng/nng.h>
+
+int nng_ctx_id(nng_ctx c);
+```
+
+### Description
+
+The `nng_ctx_id` function returns a positive identifier for the context _c_,  if it is valid.
+Otherwise it returns `-1`.
+
+A context is considered valid if it was ever opened with xref:nng_ctx_open.adoc[`nng_ctx_open`].
+
+Contexts that are allocated on the stack or statically should be initialized with the macro ((`NNG_CTX_INITIALIZER`)) to ensure that they cannot be confused with another valid context.
+
+### Return Values
+
+This function returns the positive value for the context identifier, or `-1` if the context is invalid.
+
+
+### See Also
+
+xref:nng_ctx_open.adoc[nng_ctx_open]
diff --git a/docs/ref/ctx/nng_ctx_open.adoc b/docs/ref/ctx/nng_ctx_open.adoc
new file mode 100644
index 00000000..d3604e4a
--- /dev/null
+++ b/docs/ref/ctx/nng_ctx_open.adoc
@@ -0,0 +1,39 @@
+## nng_ctx_open
+
+Create context.
+
+### Synopsis
+
+```c
+#include <nng/nng.h>
+
+int nng_ctx_open(nng_ctx *ctxp, nng_socket s);
+```
+
+### Description
+
+The `nng_ctx_open` function creates a separate ((context)) to be used with the socket _s_, and returns it at the location pointed by _ctxp_.
+Only stateful protocols support creation of separate contexts.footnote:[Stateless protocols by their very nature have no need for contexts.]
+
+Contexts allow the independent and concurrent use of stateful operations using the same socket.footnote:[For example, two different contexts created on a xref:../proto/rep.adoc[_rep_] socket can each receive requests, and send replies to them, without any regard to or interference with each other.]
+
+TIP: Using contexts is an excellent way to write simpler concurrent applications, while retaining the benefits of the protocol-specific
+advanced processing, avoiding the need to bypass that with xref:nng.adoc#raw_mode[raw mode](((raw mode))) sockets.footnote:[Use of contexts with xref:nng.adoc#raw_mode[raw mode] sockets is nonsensical, and not supported.]
+
+### Return Values
+
+This function returns 0 on success, and non-zero otherwise.
+
+### Errors
+
+[horizontal]
+`NNG_ENOMEM`:: Insufficient memory is available.
+`NNG_ENOTSUP`:: The protocol does not support separate contexts, or the socket was opened in raw mode.
+
+### See Also
+
+xref:nng_ctx_close.adoc[nng_ctx_close],
+xref:nng_ctx_get.adoc[nng_ctx_get],
+xref:nng_ctx_recv.adoc[nng_ctx_recv],
+xref:nng_ctx_send.adoc[nng_ctx_send],
+xref:nng_ctx_set.adoc[nng_ctx_set]
diff --git a/docs/ref/ctx/nng_ctx_recv.adoc b/docs/ref/ctx/nng_ctx_recv.adoc
new file mode 100644
index 00000000..dc50f8bc
--- /dev/null
+++ b/docs/ref/ctx/nng_ctx_recv.adoc
@@ -0,0 +1,45 @@
+## nng_ctx_recv
+
+Receive message using context asynchronously.
+
+### Synopsis
+
+```c
+#include <nng/nng.h>
+
+void nng_ctx_recv(nng_ctx ctx, nng_aio *aio);
+```
+
+### Description
+
+The `nng_ctx_recv` function receives a xref:../msg/index.adoc[message] using the context _s_ asynchronously.
+
+When a message is successfully received by the context, it is stored in the _aio_ and the completion callback on the _aio_ is executed.
+In this case, xref:nng_aio_result.adoc[`nng_aio_result`] will return zero.
+The received message will be available via xref:nng_aio_get_msg.adoc[`nng_aio_get_msg`]. 
+The callback function is responsible for retrieving the message and disposing of it appropriately.
+
+IMPORTANT: Failing to accept and dispose of the message in this case will leak the message.
+
+If for some reason the asynchronous receive does not complete successfully, then the callback will be executed and xref:nng_aio_result.adoc[`nng_aio_result`] will return a non-zero error.
+In this case there will be no message in the _aio_.
+
+TIP: The semantics of what receiving a message means varies from protocol to protocol, so examination of the protocol documentation is encouraged.
+
+### Errors
+
+[horizontal]
+`NNG_ECANCELED`:: The operation was aborted.
+`NNG_ECLOSED`:: The context _ctx_ is not open.
+`NNG_ENOMEM`:: Insufficient memory is available.
+`NNG_ENOTSUP`:: The protocol for context _ctx_ does not support receiving.
+`NNG_ESTATE`:: The context _ctx_ cannot receive data in this state.
+`NNG_ETIMEDOUT`:: The receive timeout expired.
+
+### See Also
+
+xref:../aio/index.adoc[Asynchronous I/O],
+xref:../msg/index.adoc[Messages],
+xref:../aio/nng_aio_get_msg.adoc[nng_aio_get_msg],
+xref:../aio/nng_aio_result.adoc[nng_aio_result],
+xref:../aio/nng_ctx_recvmsg[nng_ctx_recvmsg]
diff --git a/docs/ref/ctx/nng_ctx_recvmsg.adoc b/docs/ref/ctx/nng_ctx_recvmsg.adoc
new file mode 100644
index 00000000..f5c8db03
--- /dev/null
+++ b/docs/ref/ctx/nng_ctx_recvmsg.adoc
@@ -0,0 +1,43 @@
+## nng_ctx_recvmsg
+
+Receive message using context.
+
+### Synopsis
+
+```c
+#include <nng/nng.h>
+
+int nng_ctx_recvmsg(nng_ctx ctx, nng_msg **msgp, int flags);
+```
+
+### Description
+
+The `nng_ctx_recvmsg` receives a message on context _ctx_, storing the received xref:../msg/index.adoc[message] at the location pointed to by _msgp_.
+
+The _flags_ may contain the following value:
+
+`NNG_FLAG_NONBLOCK`::
+  The function returns immediately, even if no message is available.
+  Without this flag, the function will wait until a message is receivable on the context _ctx_, or any configured timer expires.
+
+TIP: The semantics of what receiving a message means vary from protocol to protocol, so examination of the protocol documentation is encouraged.
+
+### Return Values
+
+This function returns 0 on success, and non-zero otherwise.
+
+### Errors
+
+[horizontal]
+`NNG_EAGAIN`:: The operation would block, but `NNG_FLAG_NONBLOCK` was specified.
+`NNG_ECLOSED`:: The context or socket is not open.
+`NNG_EINVAL`:: An invalid set of _flags_ was specified.
+`NNG_ENOMEM`:: Insufficient memory is available.
+`NNG_ENOTSUP`:: The protocol does not support receiving.
+`NNG_ESTATE`:: The context cannot receive data in this state.
+`NNG_ETIMEDOUT`:: The operation timed out.
+
+### See Also
+
+xref:../msg/index.adoc[Messages],
+xref:nng_ctx_recv.adoc[nng_ctx_recv]
diff --git a/docs/ref/ctx/nng_ctx_send.adoc b/docs/ref/ctx/nng_ctx_send.adoc
new file mode 100644
index 00000000..2490010a
--- /dev/null
+++ b/docs/ref/ctx/nng_ctx_send.adoc
@@ -0,0 +1,46 @@
+## nng_ctx_send
+
+Send message using context asynchronously.
+
+### Synopsis
+
+```c
+#include <nng/nng.h>
+
+void nng_ctx_send(nng_ctx ctx, nng_aio *aio);
+```
+
+### Description
+
+The `nng_ctx_send` sends a xref:../msg/index.adoc[message] using the context _ctx_ asynchronously.
+
+The message to send must have previously been set on the _aio_ using the xref:../aio/nng_aio_set_msg.adoc[`nng_aio_set_msg`] function.
+
+If the message was successfully queued for delivery to the socket, then the _aio_ will be completed, and xref:../aio/nng_aio_result.adoc[`nng_aio_result`] will return zero.
+In this case the context will dispose of the message when it is finished with it.
+
+NOTE: The operation will complete, and the callback associated with the _aio_ will execute, as soon as the socket accepts the message for delivery.
+This does _not_ indicate that the message was actually delivered, as it may still be buffered in the sending or receiving sockets, or in flight over the physical medium.
+
+If the operation fails for any reason, then the _aio_ callback will be executed and `nng_aio_result` will return a non-zero error status.
+In this case, the callback has a responsibility to retrieve the message from the _aio_ with xref:nng_aio_get_msg.adoc[`nng_aio_get_msg`] and dispose of it appropriately.footnote:[This may include re-sending on the same or a different socket, or deallocating the message with xref:../msg/nng_msg_free.adoc[`nng_msg_free`].]
+
+TIP: The semantics of what sending a message means varies from protocol to protocol, so examination of the protocol documentation is encouraged.
+
+### Errors
+
+[horizontal]
+`NNG_ECANCELED`:: The operation was aborted.
+`NNG_ECLOSED`:: The context _ctx_ is not open.
+`NNG_EMSGSIZE`:: The message is too large.
+`NNG_ENOMEM`:: Insufficient memory is available.
+`NNG_ENOTSUP`:: The protocol for context _ctx_ does not support sending.
+`NNG_ESTATE`:: The context _ctx_ cannot send data in this state.
+`NNG_ETIMEDOUT`:: The send timeout expired.
+
+### See Also
+
+xref:../aio/index.adoc[Asynchronous I/O],
+xref:../msg/index.adoc[Messages],
+xref:../aio/nng_aio_get_msg.adoc[nng_aio_get_msg],
+xref:../aio/nng_aio_set_msg.adoc[nng_aio_set_msg]
diff --git a/docs/ref/ctx/nng_ctx_sendmsg.adoc b/docs/ref/ctx/nng_ctx_sendmsg.adoc
new file mode 100644
index 00000000..2eda9e7b
--- /dev/null
+++ b/docs/ref/ctx/nng_ctx_sendmsg.adoc
@@ -0,0 +1,63 @@
+## nng_ctx_sendmsg
+
+Send message using context.
+
+### Synopsis
+
+```c
+#include <nng/nng.h>
+
+int nng_ctx_sendmsg(nng_ctx c, nng_msg *msg, int flags);
+```
+
+### Description
+
+The `nng_ctx_sendmsg` sends message _msg_ using the context _ctx_.
+
+If the function returns zero, indicating it has accepted the message for delivery, then the _msg_ is owned by the context, and the caller must not make any further use of it.
+The context will free the message when it is finished.
+
+If the function returns non-zero, then it is the caller's responsibility to dispose of the _msg_, which may include freeing it, sending it to another socket, or simply trying again later.
+
+TIP: The semantics of what sending a message means vary from protocol to protocol, so examination of the protocol documentation is encouraged.
+
+The _flags_ may contain the following value:
+
+`NNG_FLAG_NONBLOCK`::
+    The function returns immediately, regardless of whether the context is able to accept the data or not.
+    If the context is unable to accept the data{empty}footnote:[Such as if backpressure exists because the peers are consuming messages too slowly, or no peer is present.], then the function will return with `NNG_EAGAIN`.
+    If this flag is not specified, then the function will block if such a condition exists.
+
+
+NOTE: Regardless of the presence or absence of `NNG_FLAG_NONBLOCK`, there may
+be queues between the sender and the receiver.
+Furthermore, there is no guarantee that the message has actually been delivered.
+Finally, with some protocols, the semantic is implicitly `NNG_FLAG_NONBLOCK`.
+
+### Return Values
+
+This function returns 0 on success, and non-zero otherwise.
+
+### Errors
+
+[horizontal]
+`NNG_EAGAIN`:: The operation would block, but `NNG_FLAG_NONBLOCK` was specified.
+`NNG_ECLOSED`:: The context or socket is not open.
+`NNG_EINVAL`:: An invalid set of _flags_ was specified.
+`NNG_EMSGSIZE`:: The value of _size_ is too large.
+`NNG_ENOMEM`:: Insufficient memory is available.
+`NNG_ENOTSUP`:: The protocol does not support sending.
+`NNG_ESTATE`:: The context cannot send data in this state.
+`NNG_ETIMEDOUT`:: The operation timed out.
+
+### See Also
+
+xref:nng_msg_alloc.adoc[nng_msg_alloc],
+xref:nng_ctx_open.adoc[nng_ctx_open],
+xref:nng_ctx_recvmsg.adoc[nng_ctx_recvmsg],
+xref:nng_ctx_send.adoc[nng_ctx_send],
+xref:nng_sendmsg.adoc[nng_sendmsg],
+xref:nng_strerror.adoc[nng_strerror],
+xref:nng_msg.adoc[nng_msg],
+xref:nng_ctx.adoc[nng_ctx],
+xref:nng.adoc[nng]
diff --git a/docs/ref/ctx/nng_ctx_set.adoc b/docs/ref/ctx/nng_ctx_set.adoc
new file mode 100644
index 00000000..a6b6eef4
--- /dev/null
+++ b/docs/ref/ctx/nng_ctx_set.adoc
@@ -0,0 +1,81 @@
+## nng_ctx_set
+
+Set context option.
+
+### Synopsis
+
+```c
+#include <nng/nng.h>
+
+int nng_ctx_set(nng_ctx ctx, const char *opt, const void *val, size_t valsz);
+
+int nng_ctx_set_bool(nng_ctx ctx, const char *opt, int bval);
+
+int nng_ctx_set_int(nng_ctx ctx, const char *opt, int ival);
+
+int nng_ctx_set_ms(nng_ctx ctx, const char *opt, nng_duration dur);
+
+int nng_ctx_set_size(nng_ctx ctx, const char *opt, size_t z);
+
+int nng_ctx_set_string(nng_ctx ctx, const char *opt, const char *str);
+
+int nng_ctx_set_uint64(nng_ctx ctx, const char *opt, uint64_t u64);
+```
+
+### Description
+
+(((options, context)))
+The `nng_ctx_set` functions are used to configure options for the context _ctx_.
+The actual options that may be configured in this way vary, and are specified by _opt_.
+
+TIP: Context options are protocol specific.
+See the option documentation for more information.
+
+#### Forms
+
+The details of the type, size, and semantics of the option will depend on the actual option, and will be documented with the option itself.
+
+`nng_ctx_set`::
+This function is untyped, and can be used to configure any arbitrary data.
+The _val_ pointer addresses the data to copy, and _valsz_ is the size of the objected located at _val_.
+
+TIP: It may be easier to use one of the typed forms of this function.
+
+`nng_ctx_set_bool`::
+This function sets a Boolean (`bool`) option to _bval_.
+
+`nng_ctx_set_int`::
+This function sets an integer (`int`) option to _ival_.
+
+`nng_ctx_set_ms`::
+This function sets a duration (xref:nng_duration.adoc[`nng_duration`]) option to _dur_, which is an integer number of milliseconds.
+
+`nng_ctx_set_size`::
+This function sets a size (`size_t`) option to _z_.
+
+`nng_ctx_set_string`::
+This function sets a string (`const char *`) option to _str_.
+Strings passed this way must be legal UTF-8 or ASCII strings, terminated with a `NUL` (`\0`) byte.
+(Other constraints may apply as well, see the documentation for each option for details.)
+
+`nng_ctx_set_uint64`::
+This function sets a 64-bit unsigned integer (`uint64_t`) option to _u64_.
+
+### Return Values
+
+These functions return 0 on success, and non-zero otherwise.
+
+### Errors
+
+[horizontal]
+`NNG_ECLOSED`:: Parameter _s_ does not refer to an open socket.
+`NNG_EINVAL`:: The value being passed is invalid.
+`NNG_ENOTSUP`:: The option _opt_ is not supported.
+`NNG_EREADONLY`:: The option _opt_ is read-only.
+`NNG_ESTATE`:: The socket is in an inappropriate state for setting this option.
+
+### See Also
+
+xref:../opts/index.adoc[Options],
+xref:nng_ctx_get.adoc[nng_ctx_get],
+xref:nng_socket_set.adoc[nng_socket_set]
diff --git a/docs/ref/ctx/nng_ctx_setopt.adoc b/docs/ref/ctx/nng_ctx_setopt.adoc
new file mode 100644
index 00000000..df6eda4d
--- /dev/null
+++ b/docs/ref/ctx/nng_ctx_setopt.adoc
@@ -0,0 +1,43 @@
+## nng_ctx_setopt
+
+Set context option (deprecated).
+
+### Synopsis
+
+```c
+#include <nng/nng.h>
+
+int nng_ctx_setopt(nng_ctx ctx, const char *opt, const void *val, size_t valsz);
+int nng_ctx_setopt_bool(nng_ctx ctx, const char *opt, int bval);
+int nng_ctx_setopt_int(nng_ctx ctx, const char *opt, int ival);
+int nng_ctx_setopt_ms(nng_ctx ctx, const char *opt, nng_duration dur);
+int nng_ctx_setopt_size(nng_ctx ctx, const char *opt, size_t z);
+int nng_ctx_setopt_string(nng_ctx ctx, const char *opt, const char *str);
+int nng_ctx_setopt_uint64(nng_ctx ctx, const char *opt, uint64_t u64);
+```
+
+### Description
+
+NOTE: These functions are deprecated.
+They may not be present if the library was built with ((`NNG_ELIDE_DEPRECATED`)).
+
+These deprecated functions have one-to-one modern equivalents with the same arguments and semantics, as follows:
+
+[width=50%,]
+|===
+| Legacy Function | Modern Equivalent
+
+| `nng_ctx_setopt` | `nng_ctx_set`
+| `nng_ctx_setopt_bool`| `nng_ctx_set_bool`
+| `nng_ctx_setopt_int`| `nng_ctx_set_int`
+| `nng_ctx_setopt_ms`| `nng_ctx_set_ms`
+| `nng_ctx_setopt_size`| `nng_ctx_set_size`
+| `nng_ctx_setopt_string`| `nng_ctx_set_string`
+| `nng_ctx_setopt_uint64`| `nng_ctx_set_uint64`
+|===
+
+Please see the documentation for the modern equivalents for more detail.
+
+### See Also
+
+xref:../ctx/nng_ctx_set.adoc[nng_ctx_set]