Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package gap-zeromqinterface for
openSUSE:Factory checked in at 2026-04-10 17:54:15
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/gap-zeromqinterface (Old)
and /work/SRC/openSUSE:Factory/.gap-zeromqinterface.new.21863 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "gap-zeromqinterface"
Fri Apr 10 17:54:15 2026 rev:5 rq:1345791 version:0.18
Changes:
--------
--- /work/SRC/openSUSE:Factory/gap-zeromqinterface/gap-zeromqinterface.changes
2025-06-20 16:55:01.266195120 +0200
+++
/work/SRC/openSUSE:Factory/.gap-zeromqinterface.new.21863/gap-zeromqinterface.changes
2026-04-10 18:03:31.511877431 +0200
@@ -1,0 +2,6 @@
+Fri Apr 10 09:01:39 UTC 2026 - Jan Engelhardt <[email protected]>
+
+- Update to release 0.18
+ * No user-visible changes
+
+-------------------------------------------------------------------
Old:
----
ZeroMQInterface-0.17.tar.gz
New:
----
ZeroMQInterface-0.18.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ gap-zeromqinterface.spec ++++++
--- /var/tmp/diff_new_pack.nHaFqa/_old 2026-04-10 18:03:31.991897232 +0200
+++ /var/tmp/diff_new_pack.nHaFqa/_new 2026-04-10 18:03:31.991897232 +0200
@@ -1,7 +1,7 @@
#
# spec file for package gap-zeromqinterface
#
-# Copyright (c) 2025 SUSE LLC
+# Copyright (c) 2026 SUSE LLC and contributors
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
@@ -17,7 +17,7 @@
Name: gap-zeromqinterface
-Version: 0.17
+Version: 0.18
Release: 0
Summary: GAP: ZeroMQ bindings
License: GPL-2.0-or-later
++++++ ZeroMQInterface-0.17.tar.gz -> ZeroMQInterface-0.18.tar.gz ++++++
++++ 2998 lines of diff (skipped)
++++ retrying with extended exclude list
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' --exclude Makefile.in --exclude configure --exclude
config.guess --exclude '*.pot' --exclude mkinstalldirs --exclude aclocal.m4
--exclude config.sub --exclude depcomp --exclude install-sh --exclude ltmain.sh
old/ZeroMQInterface-0.17/CHANGES.md new/ZeroMQInterface-0.18/CHANGES.md
--- old/ZeroMQInterface-0.17/CHANGES.md 2025-06-20 13:09:01.000000000 +0200
+++ new/ZeroMQInterface-0.18/CHANGES.md 2026-04-09 02:00:00.000000000 +0200
@@ -1,5 +1,9 @@
# CHANGES to the 'ZeroMQInterface' GAP package
+## 0.18 (2026-04-09)
+
+ - Janitorial changes
+
## 0.17 (2025-20-06)
- Janitorial changes
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' --exclude Makefile.in --exclude configure --exclude
config.guess --exclude '*.pot' --exclude mkinstalldirs --exclude aclocal.m4
--exclude config.sub --exclude depcomp --exclude install-sh --exclude ltmain.sh
old/ZeroMQInterface-0.17/PackageInfo.g new/ZeroMQInterface-0.18/PackageInfo.g
--- old/ZeroMQInterface-0.17/PackageInfo.g 2025-06-20 13:09:01.000000000
+0200
+++ new/ZeroMQInterface-0.18/PackageInfo.g 2026-04-09 02:00:00.000000000
+0200
@@ -10,8 +10,8 @@
PackageName := "ZeroMQInterface",
Subtitle := "ZeroMQ bindings for GAP",
-Version := "0.17",
-Date := "20/06/2025", # dd/mm/yyyy format
+Version := "0.18",
+Date := "09/04/2026", # dd/mm/yyyy format
License := "GPL-2.0-or-later",
Persons := [
@@ -95,6 +95,7 @@
GAP := ">= 4.12",
NeededOtherPackages := [ [ "GAPDoc", ">= 1.6.1" ] ],
SuggestedOtherPackages := [ ],
+ NeededSystemPackages := rec( Ubuntu := [["libzmq3-dev"]], Homebrew :=
[["zmq"]] ),
ExternalConditions := [ ],
),
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' --exclude Makefile.in --exclude configure --exclude
config.guess --exclude '*.pot' --exclude mkinstalldirs --exclude aclocal.m4
--exclude config.sub --exclude depcomp --exclude install-sh --exclude ltmain.sh
old/ZeroMQInterface-0.17/README.md new/ZeroMQInterface-0.18/README.md
--- old/ZeroMQInterface-0.17/README.md 2025-06-20 13:09:01.000000000 +0200
+++ new/ZeroMQInterface-0.18/README.md 2026-04-09 02:00:00.000000000 +0200
@@ -1,4 +1,4 @@
-[](https://github.com/gap-packages/ZeroMQInterface/actions?query=workflow%3ACI+branch%3Amaster)
+[](https://github.com/gap-packages/ZeroMQInterface/actions/workflows/CI.yml)
[](https://codecov.io/gh/gap-packages/ZeroMQInterface)
# The ZeroMQInterface GAP package
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' --exclude Makefile.in --exclude configure --exclude
config.guess --exclude '*.pot' --exclude mkinstalldirs --exclude aclocal.m4
--exclude config.sub --exclude depcomp --exclude install-sh --exclude ltmain.sh
old/ZeroMQInterface-0.17/doc/ZeroMQInterface.tex
new/ZeroMQInterface-0.18/doc/ZeroMQInterface.tex
--- old/ZeroMQInterface-0.17/doc/ZeroMQInterface.tex 1970-01-01
01:00:00.000000000 +0100
+++ new/ZeroMQInterface-0.18/doc/ZeroMQInterface.tex 2026-04-09
02:00:00.000000000 +0200
@@ -0,0 +1,1084 @@
+% generated by GAPDoc2LaTeX from XML source (Frank Luebeck)
+\documentclass[a4paper,11pt]{report}
+
+\usepackage[top=37mm,bottom=37mm,left=27mm,right=27mm]{geometry}
+\sloppy
+\pagestyle{myheadings}
+\usepackage{amssymb}
+\usepackage[utf8]{inputenc}
+\usepackage{makeidx}
+\makeindex
+\usepackage{color}
+\definecolor{FireBrick}{rgb}{0.5812,0.0074,0.0083}
+\definecolor{RoyalBlue}{rgb}{0.0236,0.0894,0.6179}
+\definecolor{RoyalGreen}{rgb}{0.0236,0.6179,0.0894}
+\definecolor{RoyalRed}{rgb}{0.6179,0.0236,0.0894}
+\definecolor{LightBlue}{rgb}{0.8544,0.9511,1.0000}
+\definecolor{Black}{rgb}{0.0,0.0,0.0}
+
+\definecolor{linkColor}{rgb}{0.0,0.0,0.554}
+\definecolor{citeColor}{rgb}{0.0,0.0,0.554}
+\definecolor{fileColor}{rgb}{0.0,0.0,0.554}
+\definecolor{urlColor}{rgb}{0.0,0.0,0.554}
+\definecolor{promptColor}{rgb}{0.0,0.0,0.589}
+\definecolor{brkpromptColor}{rgb}{0.589,0.0,0.0}
+\definecolor{gapinputColor}{rgb}{0.589,0.0,0.0}
+\definecolor{gapoutputColor}{rgb}{0.0,0.0,0.0}
+
+%% for a long time these were red and blue by default,
+%% now black, but keep variables to overwrite
+\definecolor{FuncColor}{rgb}{0.0,0.0,0.0}
+%% strange name because of pdflatex bug:
+\definecolor{Chapter }{rgb}{0.0,0.0,0.0}
+\definecolor{DarkOlive}{rgb}{0.1047,0.2412,0.0064}
+
+
+\usepackage{fancyvrb}
+
+\usepackage{mathptmx,helvet}
+\usepackage[T1]{fontenc}
+\usepackage{textcomp}
+
+
+\usepackage[
+ pdftex=true,
+ bookmarks=true,
+ a4paper=true,
+ pdftitle={Written with GAPDoc},
+ pdfcreator={LaTeX with hyperref package / GAPDoc},
+ colorlinks=true,
+ backref=page,
+ breaklinks=true,
+ linkcolor=linkColor,
+ citecolor=citeColor,
+ filecolor=fileColor,
+ urlcolor=urlColor,
+ pdfpagemode={UseNone},
+ ]{hyperref}
+
+\newcommand{\maintitlesize}{\fontsize{50}{55}\selectfont}
+
+% write page numbers to a .pnr log file for online help
+\newwrite\pagenrlog
+\immediate\openout\pagenrlog =\jobname.pnr
+\immediate\write\pagenrlog{PAGENRS := [}
+\newcommand{\logpage}[1]{\protect\write\pagenrlog{#1, \thepage,}}
+%% were never documented, give conflicts with some additional packages
+
+\newcommand{\GAP}{\textsf{GAP}}
+
+%% nicer description environments, allows long labels
+\usepackage{enumitem}
+\setdescription{style=nextline}
+
+%% depth of toc
+\setcounter{tocdepth}{1}
+
+
+
+
+
+%% command for ColorPrompt style examples
+\newcommand{\gapprompt}[1]{\color{promptColor}{\bfseries #1}}
+\newcommand{\gapbrkprompt}[1]{\color{brkpromptColor}{\bfseries #1}}
+\newcommand{\gapinput}[1]{\color{gapinputColor}{#1}}
+
+
+\begin{document}
+
+\logpage{[ 0, 0, 0 ]}
+\begin{titlepage}
+\mbox{}\vfill
+
+\begin{center}{\maintitlesize \textbf{ ZeroMQInterface \mbox{}}}\\
+\vfill
+
+\hypersetup{pdftitle= ZeroMQInterface }
+\markright{\scriptsize \mbox{}\hfill ZeroMQInterface \hfill\mbox{}}
+{\Huge \textbf{ ZeroMQ bindings for \textsf{GAP} \mbox{}}}\\
+\vfill
+
+{\Huge 0.18 \mbox{}}\\[1cm]
+{ 9 April 2026 \mbox{}}\\[1cm]
+\mbox{}\\[2cm]
+{\Large \textbf{ Markus Pfeiffer\\
+ \mbox{}}}\\
+{\Large \textbf{ Reimer Behrends\\
+ \mbox{}}}\\
+\hypersetup{pdfauthor= Markus Pfeiffer\\
+ ; Reimer Behrends\\
+ }
+\end{center}\vfill
+
+\mbox{}\\
+{\mbox{}\\
+\small \noindent \textbf{ Markus Pfeiffer\\
+ } Email: \href{mailto://[email protected]}
{\texttt{markus.pfeiffer@st\texttt{\symbol{45}}andrews.ac.uk}}\\
+ Homepage: \href{http://www.morphism.de/~markusp/}
{\texttt{http://www.morphism.de/\texttt{\symbol{126}}markusp/}}\\
+ Address: \begin{minipage}[t]{8cm}\noindent
+ School of Computer Science\\
+ University of St Andrews\\
+ Jack Cole Building, North Haugh\\
+ St Andrews, Fife, KY16 9SX\\
+ United Kingdom\\
+ \end{minipage}
+}\\
+{\mbox{}\\
+\small \noindent \textbf{ Reimer Behrends\\
+ } Email: \href{mailto://[email protected]}
{\texttt{[email protected]}}\\
+ Homepage:
\href{http://www.mathematik.uni-kl.de/agag/mitglieder/wissenschaftliche-mitarbeiter/dr-reimer-behrends/}
{\texttt{http://www.mathematik.uni\texttt{\symbol{45}}kl.de/agag/mitglieder/wissenschaftliche\texttt{\symbol{45}}mitarbeiter/dr\texttt{\symbol{45}}reimer\texttt{\symbol{45}}behrends/}}\\
+ Address: \begin{minipage}[t]{8cm}\noindent
+ Technische Universit{\"a}t Kaiserslautern\\
+ Fachbereich Mathematik\\
+ Postfach 3049\\
+ 67653 Kaiserslautern\\
+ Deutschland\\
+ \end{minipage}
+}\\
+\end{titlepage}
+
+\newpage\setcounter{page}{2}
+{\small
+\section*{Copyright}
+\logpage{[ 0, 0, 1 ]}
+ {\copyright} 2015\texttt{\symbol{45}}17 by Markus Pfeiffer, Reimer Behrends
+and others
+
+ The \textsf{ZeroMQInterface} package is free software; you can redistribute
it and/or modify it under the
+terms of the \href{http://www.fsf.org/licenses/gpl.html} {GNU General Public
License} as published by the Free Software Foundation; either version 2 of the
License,
+or (at your option) any later version. \mbox{}}\\[1cm]
+{\small
+\section*{Acknowledgements}
+\logpage{[ 0, 0, 2 ]}
+ We appreciate very much all past and future comments, suggestions and
+contributions to this package and its documentation provided by \textsf{GAP}
users and developers. \mbox{}}\\[1cm]
+\newpage
+
+\def\contentsname{Contents\logpage{[ 0, 0, 3 ]}}
+
+\tableofcontents
+\newpage
+
+
+\chapter{\textcolor{Chapter }{Introduction}}\label{Intro}
+\logpage{[ 1, 0, 0 ]}
+\hyperdef{L}{X7DFB63A97E67C0A1}{}
+{
+
+\section{\textcolor{Chapter }{Purpose and goals of this package}}\logpage{[ 1,
1, 0 ]}
+\hyperdef{L}{X7F0445BA85C0D680}{}
+{
+ This package provides low\texttt{\symbol{45}}level bindings to the popular
\href{http://zeromq.org} {ZeroMQ} distributed messaging framework for
\textsf{GAP} and \textsf{HPC\texttt{\symbol{45}}GAP} as well as some higher
level functions to ease the use of distributed
+messaging in \textsf{GAP} }
+
+
+\section{\textcolor{Chapter }{Overview over this manual}}\logpage{[ 1, 2, 0 ]}
+\hyperdef{L}{X786BACDB82918A65}{}
+{
+ Chapter \ref{ZeroMQ Bindings} gives an overview of the available bindings,
and examples of how to use them.
+Chapter \ref{Using ZeroMQ with the zgap script} showcases one way of using
\textsf{ZeroMQInterface}. }
+
+
+\section{\textcolor{Chapter }{Installation}}\logpage{[ 1, 3, 0 ]}
+\hyperdef{L}{X8360C04082558A12}{}
+{
+ To use this package \href{https://zeromq.org} {ZeroMQ} needs to be installed
on your system and the \textsf{ZeroMQInterface} package itself needs to be
compiled. To install \href{https://zeromq.org} {ZeroMQ} please refer to its
\href{http://zeromq.org/intro:get-the-software} {installation instructions}. To
compile this package, inside its root directory run:
+\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
+ !gapprompt@>| !gapinput@./configure|
+ !gapprompt@>| !gapinput@make|
+\end{Verbatim}
+ Or
+\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
+ !gapprompt@>| !gapinput@./configure --with-zmq=path-to-your-zeromq|
+ !gapprompt@>| !gapinput@make|
+\end{Verbatim}
+ to specify where \href{https://zeromq.org} {ZeroMQ} is located in you system.
}
+
+
+\section{\textcolor{Chapter }{Feedback}}\label{feedback}
+\logpage{[ 1, 4, 0 ]}
+\hyperdef{L}{X80D704CC7EBFDF7A}{}
+{
+ For bug reports, feature requests and suggestions, please use our
\href{https://github.com/gap-packages/ZeroMQInterface/issues} {issue tracker}. }
+
+ }
+
+
+\chapter{\textcolor{Chapter }{ZeroMQ Bindings}}\label{ZeroMQ Bindings}
+\logpage{[ 2, 0, 0 ]}
+\hyperdef{L}{X7EDFD3BB831063E7}{}
+{
+ There are experimental bindings to the ZeroMQ library available
\href{http://www.zeromq.net/} {\texttt{http://www.zeromq.net/}}. This section
describes these bindings. Messages in ZeroMQ are sent between
+endpoints called \emph{sockets}. Each socket can be \emph{bound} to an address
specified by a URI and other sockets can \emph{connect} to the same address to
exchange messages with that socket.
+\section{\textcolor{Chapter }{Addresses, transports, and
URIs}}\label{Addresses, transports, and URIs}
+\logpage{[ 2, 1, 0 ]}
+\hyperdef{L}{X7D65C84A87343B32}{}
+{
+ Addresses are specified as URIs of one of four different types (TCP, IPC,
+in\texttt{\symbol{45}}process, PGM/EPGM), each for a different type of
+transport.
+\subsection{\textcolor{Chapter }{The TCP transport}}\label{The TCP transport}
+\logpage{[ 2, 1, 1 ]}
+\hyperdef{L}{X82D04A897E0720CC}{}
+{
+ TCP URIs map to POSIX TCP stream sockets. The URI is of the form
\texttt{tcp://{\textless}address{\textgreater}:{\textless}port{\textgreater}}
or \texttt{tcp://*:{\textless}port{\textgreater}}. Here, \texttt{address} is an
internet address, either an IP address or a symbolic address (note that
+to resolve symbolic addresses, the library may have to consult DNS servers,
+which can take an indefinite amount of time or even fail). Port is a TCP port
+number. If a ``*'' is given instead of an address, this describes the
+so\texttt{\symbol{45}}called unspecified address; the URI can only be used for
+binding and will then accept incoming connections from all interfaces (as in
+binding to ``0.0.0.0'' in IPv4 or ``::'' in IPv6). }
+
+
+\subsection{\textcolor{Chapter }{The IPC transport}}\label{The IPC transport}
+\logpage{[ 2, 1, 2 ]}
+\hyperdef{L}{X792BDF3F7AB76A99}{}
+{
+ The URI for IPC communication is of the form
\texttt{ipc://{\textless}path{\textgreater}}, where \texttt{path} is an actual
path on the file system. Binding to such a URI will create a file
+in that location.
+\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
+ !gapprompt@gap>| !gapinput@socket := ZmqDealerSocket();;|
+ !gapprompt@gap>| !gapinput@ZmqBind(socket, "ipc:///tmp/connector");|
+\end{Verbatim}
+ }
+
+
+\subsection{\textcolor{Chapter }{The in\texttt{\symbol{45}}process
transport}}\label{The in-process transport}
+\logpage{[ 2, 1, 3 ]}
+\hyperdef{L}{X7AD7D8897DF0E66D}{}
+{
+ The in\texttt{\symbol{45}}process transport is used to communicate between
+threads in order to avoid the overhead of operating system calls. Messages are
+simply being copied from one thread's memory to the other's.
+In\texttt{\symbol{45}}process URIs are of the form
\texttt{inproc://{\textless}string{\textgreater}}, where \texttt{string} is an
arbitrary string. }
+
+ }
+
+
+\section{\textcolor{Chapter }{Creating and closing sockets}}\label{Creating
and closing sockets}
+\logpage{[ 2, 2, 0 ]}
+\hyperdef{L}{X7C848DC87D0C1BF0}{}
+{
+ Sockets are generally being created via calls to \texttt{ZmqPushSocket}
(\ref{ZmqPushSocket}), etc. Each such call takes two optional arguments, a URI
and an identity. If
+a URI is given, a call to \texttt{ZmqAttach} (\ref{ZmqAttach}) will be
performed immediately with the socket and URI. In particular, if the
+URI is prefixed with a ``+'' character, then the socket will connect to the
address specified by the part
+after the ``+'' character; otherwise, it will be bound to the URI.
+\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
+ !gapprompt@gap>| !gapinput@z := ZmqPushSocket("inproc://test"); # binds to
inproc://test|
+ !gapprompt@gap>| !gapinput@z := ZmqPushSocket("+inproc://test"); # connects
to inproc://test|
+\end{Verbatim}
+ If an identity is also provided, the library will call
\texttt{ZmqSetIdentity} (\ref{ZmqSetIdentity}) to set the identity (name) for
that socket. For a precise description of the
+behavior of each socket type, please consult the original ZeroMQ documentation
+for \texttt{zmq{\textunderscore}socket()}.
+
+\subsection{\textcolor{Chapter }{ZmqPushSocket}}
+\logpage{[ 2, 2, 1 ]}\nobreak
+\hyperdef{L}{X7E37F9DD7F0977F2}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqPushSocket({\mdseries\slshape
[uri[, identity]]})\index{ZmqPushSocket@\texttt{ZmqPushSocket}}
+\label{ZmqPushSocket}
+}\hfill{\scriptsize (function)}}\\
+
+
+ A push socket is one end of a unidirectional pipe. Programs can send messages
+to it, which will be delivered to a matched pull socket at the other end. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqPullSocket}}
+\logpage{[ 2, 2, 2 ]}\nobreak
+\hyperdef{L}{X7B2AB9A47F658EB7}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqPullSocket({\mdseries\slshape
[uri[, identity]]})\index{ZmqPullSocket@\texttt{ZmqPullSocket}}
+\label{ZmqPullSocket}
+}\hfill{\scriptsize (function)}}\\
+
+
+ A pull socket is the other end of a unidirectional pipe. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqReplySocket}}
+\logpage{[ 2, 2, 3 ]}\nobreak
+\hyperdef{L}{X87434250859B8460}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqReplySocket({\mdseries\slshape
[uri[, identity]]})\index{ZmqReplySocket@\texttt{ZmqReplySocket}}
+\label{ZmqReplySocket}
+}\hfill{\scriptsize (function)}}\\
+
+
+ A reply socket provides the server side of a
+remote\texttt{\symbol{45}}procedure call interaction. It alternates between
+receiving a message and sending a message to the socket from which the
+previous one originated. Deviating from that protocol (for example, by sending
+two messages in succession or receiving two without responding to the first)
+will result in an error. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqRequestSocket}}
+\logpage{[ 2, 2, 4 ]}\nobreak
+\hyperdef{L}{X8590CD6C824FE4FC}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqRequestSocket({\mdseries\slshape
[uri[, identity]]})\index{ZmqRequestSocket@\texttt{ZmqRequestSocket}}
+\label{ZmqRequestSocket}
+}\hfill{\scriptsize (function)}}\\
+
+
+ A request socket provides the client side of a
+remote\texttt{\symbol{45}}procedure call interaction. It will alternate
+between sending a message to a connected reply socket and receiving the
+response. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqPublisherSocket}}
+\logpage{[ 2, 2, 5 ]}\nobreak
+\hyperdef{L}{X79C8F8B68192DE1D}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqPublisherSocket({\mdseries\slshape
[uri[, identity]]})\index{ZmqPublisherSocket@\texttt{ZmqPublisherSocket}}
+\label{ZmqPublisherSocket}
+}\hfill{\scriptsize (function)}}\\
+
+
+ A publisher socket is a unidirectional broadcast facility. It will send each
+outgoing message to all connected subscriber sockets. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqSubscriberSocket}}
+\logpage{[ 2, 2, 6 ]}\nobreak
+\hyperdef{L}{X86A2F4EA82E1FC10}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqSubscriberSocket({\mdseries\slshape
[uri[, identity]]})\index{ZmqSubscriberSocket@\texttt{ZmqSubscriberSocket}}
+\label{ZmqSubscriberSocket}
+}\hfill{\scriptsize (function)}}\\
+
+
+ A subscriber socket receives messages from a publisher socket. It can
+subscribe to only a specific subseet of messages (see the
\texttt{ZmqSubscribe} (\ref{ZmqSubscribe}) function) or receive all of them. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqDealerSocket}}
+\logpage{[ 2, 2, 7 ]}\nobreak
+\hyperdef{L}{X7D5974927C4C3131}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqDealerSocket({\mdseries\slshape
[uri[, identity]]})\index{ZmqDealerSocket@\texttt{ZmqDealerSocket}}
+\label{ZmqDealerSocket}
+}\hfill{\scriptsize (function)}}\\
+
+
+ A dealer socket is a bidirectional socket. One or more peers can connect to
+it. Outgoing messages will be sent to those peers in a
+round\texttt{\symbol{45}}robin fashion (i.e., the first message goes to the
+first peer, the second to the second peer, and so forth until all peers have
+received a message and the process begins anew with the first peer). Incoming
+messages will be received from all peers and processed fairly (i.e., no
+message will be held indefinitely). Two dealer sockets can be used to create a
+bidirectional pipe. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqRouterSocket}}
+\logpage{[ 2, 2, 8 ]}\nobreak
+\hyperdef{L}{X7ED409848377791D}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqRouterSocket({\mdseries\slshape
[uri[, identity]]})\index{ZmqRouterSocket@\texttt{ZmqRouterSocket}}
+\label{ZmqRouterSocket}
+}\hfill{\scriptsize (function)}}\\
+
+
+ Router sockets, like dealer sockets, can have multiple peers connected to
+them. Incoming messages are handled the same way as for dealer sockets.
+Outgoing messages should be multi\texttt{\symbol{45}}part messages, where the
+first part of the message is the identity of one of the peers. The message
+will then be sent only to the peer with that identity. Peers can be dealer,
+request, or reply sockets. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqSocket}}
+\logpage{[ 2, 2, 9 ]}\nobreak
+\hyperdef{L}{X81A5B57F7AFCD80F}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqSocket({\mdseries\slshape
type})\index{ZmqSocket@\texttt{ZmqSocket}}
+\label{ZmqSocket}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqSocket} is a low\texttt{\symbol{45}}level function that is used by
\texttt{ZmqPushSocket} etc. to create sockets. Its argument is a string, one of
``PUSH'', ``PULL'', ``REP'', ``REQ'', ``PUB'', ``SUB'', ``DEALER'', ``ROUTER'',
and it creates and returns a socket of that type. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqClose}}
+\logpage{[ 2, 2, 10 ]}\nobreak
+\hyperdef{L}{X878D7DF3846B3431}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqClose({\mdseries\slshape
socket})\index{ZmqClose@\texttt{ZmqClose}}
+\label{ZmqClose}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqClose} closes \texttt{socket}. Afterwards, it cannot anymore be
bound or connected to, nor receive or send
+messages. Messages already in transit will still be delivered. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqIsOpen}}
+\logpage{[ 2, 2, 11 ]}\nobreak
+\hyperdef{L}{X7BAC106D81E8C8D2}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqIsOpen({\mdseries\slshape
socket})\index{ZmqIsOpen@\texttt{ZmqIsOpen}}
+\label{ZmqIsOpen}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqIsOpen} returns true if \texttt{socket} has not been closed yet,
false otherwise. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqSocketType}}
+\logpage{[ 2, 2, 12 ]}\nobreak
+\hyperdef{L}{X831235C47A0CFA1C}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqSocketType({\mdseries\slshape
socket})\index{ZmqSocketType@\texttt{ZmqSocketType}}
+\label{ZmqSocketType}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqSocketType} returns the string with which the socket was created
(see \texttt{ZmqSocket} (\ref{ZmqSocket})). }
+
+ }
+
+
+\section{\textcolor{Chapter }{Binding and connecting sockets to
addresses}}\label{Binding and connecting sockets to addresses}
+\logpage{[ 2, 3, 0 ]}
+\hyperdef{L}{X7E93217181B71A2B}{}
+{
+
+
+\subsection{\textcolor{Chapter }{ZmqBind}}
+\logpage{[ 2, 3, 1 ]}\nobreak
+\hyperdef{L}{X7F4A98227D65B573}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqBind({\mdseries\slshape
socket, uri})\index{ZmqBind@\texttt{ZmqBind}}
+\label{ZmqBind}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqBind} will \emph{bind} \texttt{socket} to \texttt{uri}. After
being bound to the address specified by \texttt{uri}, the socket can be
connected to at that address with \texttt{ZmqConnect} (\ref{ZmqConnect}). }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqConnect}}
+\logpage{[ 2, 3, 2 ]}\nobreak
+\hyperdef{L}{X7D00EE937F96175E}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqConnect({\mdseries\slshape
socket, uri})\index{ZmqConnect@\texttt{ZmqConnect}}
+\label{ZmqConnect}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqConnect} is used to connect \texttt{socket} to another socket that
has been bound to \texttt{uri}. Note that you can connect to an address that
has not been bound yet; in that
+case, the connection will be delayed until the binding has occurred. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqAttach}}
+\logpage{[ 2, 3, 3 ]}\nobreak
+\hyperdef{L}{X7C17743C874D56CF}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqAttach({\mdseries\slshape
socket, uri})\index{ZmqAttach@\texttt{ZmqAttach}}
+\label{ZmqAttach}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqAttach} is a unified interface for binding and connecting a
socket. If \texttt{uri} begins with a ``+'' character, then the
\texttt{ZmqConnect} (\ref{ZmqConnect}) is called with the socket and the rest
of the \texttt{uri} string following the ``+''. Otherwise, \texttt{ZmqBind}
(\ref{ZmqBind}) is called with these arguments. The intended use is to
construct a network of
+connections from a list of strings. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqSocketURI}}
+\logpage{[ 2, 3, 4 ]}\nobreak
+\hyperdef{L}{X7CB8FB7F8377B620}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqSocketURI({\mdseries\slshape
socket})\index{ZmqSocketURI@\texttt{ZmqSocketURI}}
+\label{ZmqSocketURI}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqSocketURI} returns the most recent URI to which \texttt{socket}
has been bound or connected. Sockets can be bound to or connected to multiple
+addresses, but only the most recent one is returned. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqIsBound}}
+\logpage{[ 2, 3, 5 ]}\nobreak
+\hyperdef{L}{X7C91933A84823735}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqIsBound({\mdseries\slshape
socket})\index{ZmqIsBound@\texttt{ZmqIsBound}}
+\label{ZmqIsBound}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqIsBound} returns true if the socket has been bound to the address
returned by \texttt{ZmqSocketURI()}, false otherwise. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqIsConnected}}
+\logpage{[ 2, 3, 6 ]}\nobreak
+\hyperdef{L}{X795DDB1F7A147DD2}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqIsConnected({\mdseries\slshape
socket})\index{ZmqIsConnected@\texttt{ZmqIsConnected}}
+\label{ZmqIsConnected}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqIsBound} returns true if the socket has been connected to the
address returned by \texttt{ZmqSocketURI()}, false otherwise. }
+
+ }
+
+
+\section{\textcolor{Chapter }{Sending and receiving messages}}\label{Sending
and receiving messages}
+\logpage{[ 2, 4, 0 ]}
+\hyperdef{L}{X85BF739678B524D3}{}
+{
+ ZeroMQ allows the sending and receiving of both string messages and
+multi\texttt{\symbol{45}}part messages. String messages are sequences of bytes
+(which can include zero), provided as a GAP string, while
+multi\texttt{\symbol{45}}part messages are lists of strings, provided as a GAP
+list. Multi\texttt{\symbol{45}}part messages are largely a convenience feature
+(e.g., to allow a message to have header parts without the inconvenience of
+having to encode those in a single string). When sent,
+multi\texttt{\symbol{45}}part messages will be delivered in their entirety;
+they can be retrieved one part at a time, but if the first part is available,
+the last part is available also.
+
+\subsection{\textcolor{Chapter }{ZmqSend}}
+\logpage{[ 2, 4, 1 ]}\nobreak
+\hyperdef{L}{X815164BB7FB0E8AC}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqSend({\mdseries\slshape
socket, data})\index{ZmqSend@\texttt{ZmqSend}}
+\label{ZmqSend}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqSend} will send \texttt{data} to \texttt{socket}, according to the
routing behavior of the underlying socket mechanism. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqReceive}}
+\logpage{[ 2, 4, 2 ]}\nobreak
+\hyperdef{L}{X7CBB221179C79E23}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqReceive({\mdseries\slshape
socket})\index{ZmqReceive@\texttt{ZmqReceive}}
+\label{ZmqReceive}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqReceive} will either retrieve a string message or a single part of
a
+multi\texttt{\symbol{45}}part message from \texttt{socket} and return the
result as a GAP string.
+\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
+ !gapprompt@gap>| !gapinput@z := ZmqSocket("inproc://test");;|
+ !gapprompt@gap>| !gapinput@z2 := ZmqSocket("+inproc://test");;|
+ !gapprompt@gap>| !gapinput@ZmqSend(z, "notice");|
+ !gapprompt@gap>| !gapinput@ZmqReceive(z2);|
+ "notice"
+ !gapprompt@gap>| !gapinput@ZmqSend(z, ["alpha", "beta"]);|
+ !gapprompt@gap>| !gapinput@ZmqReceive(z2);|
+ "alpha"
+ !gapprompt@gap>| !gapinput@ZmqReceive(z2);|
+ "beta"
+\end{Verbatim}
+ }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqReceiveList}}
+\logpage{[ 2, 4, 3 ]}\nobreak
+\hyperdef{L}{X7C4EA24A8034D841}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqReceiveList({\mdseries\slshape
socket})\index{ZmqReceiveList@\texttt{ZmqReceiveList}}
+\label{ZmqReceiveList}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqReceiveList} will retrieve a message in its entirety from
\texttt{socket} and return the result as a list of strings.
+\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
+ !gapprompt@gap>| !gapinput@z := ZmqPushSocket("inproc://test");;|
+ !gapprompt@gap>| !gapinput@z2 := ZmqPullSocket("+inproc://test");;|
+ !gapprompt@gap>| !gapinput@ZmqSend(z, "notice");|
+ !gapprompt@gap>| !gapinput@ZmqReceiveList(z2);|
+ [ "notice" ]
+ !gapprompt@gap>| !gapinput@ZmqSend(z, ["alpha", "beta"]);|
+ !gapprompt@gap>| !gapinput@ZmqReceiveList(z2);|
+ [ "alpha", "beta" ]
+\end{Verbatim}
+ }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqReceiveListAsString}}
+\logpage{[ 2, 4, 4 ]}\nobreak
+\hyperdef{L}{X7D448F567EE74050}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqReceiveListAsString({\mdseries\slshape
socket,
separator})\index{ZmqReceiveListAsString@\texttt{ZmqReceiveListAsString}}
+\label{ZmqReceiveListAsString}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqReceiveListAsString} works like \texttt{ZmqReceiveList}, but will
return the result a single string, with multiple parts separated by
\texttt{separator}.
+\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
+ !gapprompt@gap>| !gapinput@z := ZmqPushSocket("inproc://test");;|
+ !gapprompt@gap>| !gapinput@z2 := ZmqPullSocket("+inproc://test");;|
+ !gapprompt@gap>| !gapinput@ZmqSend(z, "notice");|
+ !gapprompt@gap>| !gapinput@ZmqReceiveListAsString(z2, "::");|
+ "notice"
+ !gapprompt@gap>| !gapinput@ZmqSend(z, ["alpha", "beta"]);|
+ !gapprompt@gap>| !gapinput@ZmqReceiveListAsString(z2, "::");|
+ "alpha::beta"
+\end{Verbatim}
+ }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqHasMore}}
+\logpage{[ 2, 4, 5 ]}\nobreak
+\hyperdef{L}{X85638A657FDE7E77}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqHasMore({\mdseries\slshape
socket})\index{ZmqHasMore@\texttt{ZmqHasMore}}
+\label{ZmqHasMore}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqHasMore} will return \texttt{true} if a socket has one or more
remaining parts of a multi\texttt{\symbol{45}}part
+message outstanding, \texttt{false} otherwise.
+\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
+ !gapprompt@gap>| !gapinput@z := ZmqPushSocket("inproc://test");;|
+ !gapprompt@gap>| !gapinput@z2 := ZmqPullSocket("+inproc://test");;|
+ !gapprompt@gap>| !gapinput@ZmqSend(z, "notice");|
+ !gapprompt@gap>| !gapinput@ZmqReceive(z2);|
+ "notice"
+ !gapprompt@gap>| !gapinput@ZmqHasMore(z2);|
+ false
+ !gapprompt@gap>| !gapinput@ZmqSend(z, ["alpha", "beta"]);|
+ !gapprompt@gap>| !gapinput@ZmqReceive(z2);|
+ "alpha"
+ !gapprompt@gap>| !gapinput@ZmqHasMore(z2);|
+ true
+ !gapprompt@gap>| !gapinput@ZmqReceive(z2);|
+ "beta"
+ !gapprompt@gap>| !gapinput@ZmqHasMore(z2);|
+ false
+\end{Verbatim}
+ }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqPoll}}
+\logpage{[ 2, 4, 6 ]}\nobreak
+\hyperdef{L}{X836D98B37DD2CD2E}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqPoll({\mdseries\slshape
inputs, outputs, timeout})\index{ZmqPoll@\texttt{ZmqPoll}}
+\label{ZmqPoll}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqPoll} is a facility to determine if messages can be received from
one of the sockets
+listed in \texttt{inputs} or sent to one of the sockets listed in
\texttt{outputs}. It returns a list of indices describing the sockets that at
least one
+message can be received from or sent to. The timeout is an integer. If
+positive, it describes a duration (in milliseconds) after which it will
+return. If zero, the function will return immediately. If it is
\texttt{\texttt{\symbol{45}}1}, then the function will block indefinitely until
at least one message can be
+retrieved from one of the sockets in \texttt{inputs} or at least one message
can be sent to one of the sockets in \texttt{outputs}. If the timeout is
non\texttt{\symbol{45}}negative, the result can be the
+empty list. It is guaranteed to have at least one element otherwise. The
+indices in the result are in the range
\texttt{[1..Length(inputs)+Length(outputs)}. An index \texttt{i} less than or
equal to \texttt{Length(inputs)} refers to the socket \texttt{inputs[i]}. An
index \texttt{j} in the range
\texttt{[Length(inputs)+1..Length(inputs)+Length(outputs)} refers to the socket
\texttt{outputs[j\texttt{\symbol{45}}Length(inputs)]}. Multiple indices are
listed in ascending order (i.e., they form a GAP set).
+\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
+ !gapprompt@gap>| !gapinput@send1 := ZmqPushSocket("inproc://#1");;|
+ !gapprompt@gap>| !gapinput@recv1 := ZmqPullSocket("+inproc://#1");;|
+ !gapprompt@gap>| !gapinput@send2 := ZmqPushSocket();;|
+ !gapprompt@gap>| !gapinput@recv2 := ZmqPullSocket();;|
+ !gapprompt@gap>| !gapinput@ZmqSetSendCapacity(send2, 1);|
+ !gapprompt@gap>| !gapinput@ZmqSetReceiveCapacity(recv2, 1);|
+ !gapprompt@gap>| !gapinput@ZmqBind(send2, "inproc://#2");|
+ !gapprompt@gap>| !gapinput@ZmqConnect(recv2, "inproc://#2");|
+ !gapprompt@gap>| !gapinput@ZmqSend(send2, "alpha");|
+ !gapprompt@gap>| !gapinput@ZmqSend(send2, "beta");|
+ !gapprompt@gap>| !gapinput@ZmqPoll([recv1, recv2], [send1, send2], 0);|
+ [ 2, 3 ]
+\end{Verbatim}
+ In the example above, the code constructs sockets \texttt{send2} and
\texttt{recv2} with a capacity to store at most one outgoing and incoming
message,
+respectively. Then the code sends two messages to \texttt{send2}, one of which
will be in the incoming buffer of \texttt{recv2}, and the other will remain in
the outgoing buffer of \texttt{send2}. At this point, no more messages can be
sent to \texttt{send2}, because its outgoing buffer is at capacity, and
\texttt{recv2} has a message that can be received. Conversely, \texttt{send1}
can still accept outgoing messages, and \texttt{recv1} has no messages. Thus,
the result is the list \texttt{[2, 3]}. The \texttt{2} refers to \texttt{recv2}
(as the second socket in the list of inputs), while \texttt{3} refers to
\texttt{send1} (as the first socket in the list of outputs). }
+
+ }
+
+
+\section{\textcolor{Chapter }{Setting and querying socket
properties}}\label{Setting and querying socket properties}
+\logpage{[ 2, 5, 0 ]}
+\hyperdef{L}{X86C414A57BE2F7A2}{}
+{
+ Sockets have properties that can be set and queried. Most such properties
only
+affect binds and connects that occur after they have been set. Binding or
+connecting a socket first and then setting a property will not change the
+behavior of the socket.
+
+\subsection{\textcolor{Chapter }{ZmqSetIdentity}}
+\logpage{[ 2, 5, 1 ]}\nobreak
+\hyperdef{L}{X7AD7274784A96783}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqSetIdentity({\mdseries\slshape
socket, string})\index{ZmqSetIdentity@\texttt{ZmqSetIdentity}}
+\label{ZmqSetIdentity}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqSetIdentity} can be used to give the socket an identity. An
identity is a string of up to
+255 characters that should not start with a null character (the null character
+is reserved for internal use). This identity should be globally unique.
+Uniqueness is not enforced, however, and undefined behavior may result from
+different sockets with the same identity interacting. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqGetIdentity}}
+\logpage{[ 2, 5, 2 ]}\nobreak
+\hyperdef{L}{X7B35DC33795EDB8F}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqGetIdentity({\mdseries\slshape
socket})\index{ZmqGetIdentity@\texttt{ZmqGetIdentity}}
+\label{ZmqGetIdentity}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqGetIdentity} returns the current identity of the socket. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqSetSendCapacity}}
+\logpage{[ 2, 5, 3 ]}\nobreak
+\hyperdef{L}{X8384175A83EE3F04}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqSetSendCapacity({\mdseries\slshape
socket, value})\index{ZmqSetSendCapacity@\texttt{ZmqSetSendCapacity}}
+\label{ZmqSetSendCapacity}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqSetSendCapacity} sets the maximum number of messages that a socket
can store in its outgoing
+buffer. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqSetReceiveCapacity}}
+\logpage{[ 2, 5, 4 ]}\nobreak
+\hyperdef{L}{X86817EA77EF5A145}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqSetReceiveCapacity({\mdseries\slshape
socket, value})\index{ZmqSetReceiveCapacity@\texttt{ZmqSetReceiveCapacity}}
+\label{ZmqSetReceiveCapacity}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqSetReceiveCapacity} sets the maximum number of messages that a
socket can store in its outgoing
+buffer. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqGetSendCapacity}}
+\logpage{[ 2, 5, 5 ]}\nobreak
+\hyperdef{L}{X7F65F8F87E198308}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqGetSendCapacity({\mdseries\slshape
socket})\index{ZmqGetSendCapacity@\texttt{ZmqGetSendCapacity}}
+\label{ZmqGetSendCapacity}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqGetSendCapacity} returns the maximum number of messages that a
socket can store in its outgoing
+buffer. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqGetReceiveCapacity}}
+\logpage{[ 2, 5, 6 ]}\nobreak
+\hyperdef{L}{X84D1C61683021D49}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqGetReceiveCapacity({\mdseries\slshape
socket})\index{ZmqGetReceiveCapacity@\texttt{ZmqGetReceiveCapacity}}
+\label{ZmqGetReceiveCapacity}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqGetReceiveCapacity} returns the maximum number of messages that a
socket can store in its incoming
+buffer. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqSetSendBufferSize}}
+\logpage{[ 2, 5, 7 ]}\nobreak
+\hyperdef{L}{X808243357C0466C5}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqSetSendBufferSize({\mdseries\slshape
socket, size})\index{ZmqSetSendBufferSize@\texttt{ZmqSetSendBufferSize}}
+\label{ZmqSetSendBufferSize}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqSetSendBufferSize} sets the size of the transmission buffer used
by the underlying operating
+system structure for sending data. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqGetSendBufferSize}}
+\logpage{[ 2, 5, 8 ]}\nobreak
+\hyperdef{L}{X86C7D8DE81F3DAC9}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqGetSendBufferSize({\mdseries\slshape
socket})\index{ZmqGetSendBufferSize@\texttt{ZmqGetSendBufferSize}}
+\label{ZmqGetSendBufferSize}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqGetSendBufferSize} returns the size of the transmission buffer
used by the underlying operating
+system structure for sending data. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqSetReceiveBufferSize}}
+\logpage{[ 2, 5, 9 ]}\nobreak
+\hyperdef{L}{X7BFF68F478CB9591}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqSetReceiveBufferSize({\mdseries\slshape
socket, size})\index{ZmqSetReceiveBufferSize@\texttt{ZmqSetReceiveBufferSize}}
+\label{ZmqSetReceiveBufferSize}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqSetReceiveBufferSize} sets the size of the transmission buffer
used by the underlying operating
+system structure for receiving data. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqGetReceiveBufferSize}}
+\logpage{[ 2, 5, 10 ]}\nobreak
+\hyperdef{L}{X811DDCF3853C299D}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqGetReceiveBufferSize({\mdseries\slshape
socket})\index{ZmqGetReceiveBufferSize@\texttt{ZmqGetReceiveBufferSize}}
+\label{ZmqGetReceiveBufferSize}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZmqGetReceiveBufferSize} returns the size of the transmission buffer
used by the underlying operating
+system structure for receiving data. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqSubscribe}}
+\logpage{[ 2, 5, 11 ]}\nobreak
+\hyperdef{L}{X79365BF47A15D740}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqSubscribe({\mdseries\slshape
socket, prefix})\index{ZmqSubscribe@\texttt{ZmqSubscribe}}
+\label{ZmqSubscribe}
+}\hfill{\scriptsize (function)}}\\
+
+
+ The \texttt{ZmqSubscribe} function can only be used for Subscriber sockets.
After calling it, only
+messages that begin with the given prefix string will be received by the
+subscriber. All others will be silently discarded. The function can be used
+multiple times, and then all messages that match any of the prefixes will be
+received. }
+
+
+
+\subsection{\textcolor{Chapter }{ZmqUnsubscribe}}
+\logpage{[ 2, 5, 12 ]}\nobreak
+\hyperdef{L}{X7916FAA27F90D773}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZmqUnsubscribe({\mdseries\slshape
socket, prefix})\index{ZmqUnsubscribe@\texttt{ZmqUnsubscribe}}
+\label{ZmqUnsubscribe}
+}\hfill{\scriptsize (function)}}\\
+
+
+ The \texttt{ZmqUnsubscribe} function removes the given prefix string from the
socket's subscription list. }
+
+ }
+
+ }
+
+
+\chapter{\textcolor{Chapter }{Using ZeroMQ with the zgap script}}\label{Using
ZeroMQ with the zgap script}
+\logpage{[ 3, 0, 0 ]}
+\hyperdef{L}{X823ACE5A8380FB0D}{}
+{
+ The \texttt{zgap} script provides facilities to start a number of child
processes controlled by
+a single master process and to allow for easy coordination between them.
+\section{\textcolor{Chapter }{Running zgap}}\label{Running zgap}
+\logpage{[ 3, 1, 0 ]}
+\hyperdef{L}{X7E80C0DB7D68DA60}{}
+{
+ From the shell, run zgap via:
+\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
+ bin/zgap -N <nodes> <gap_options> <gap_files>
+\end{Verbatim}
+ Here, \texttt{nodes} should be a positive integer that describes the number
of workers one wishes
+to start. The rest of the command line, consisting of gap options and gap
+files, will be passed to the master and the worker processes verbatim. This
+allows, for example, the initialization of functions that need to be known by
+all workers. The first line of output will be prefixed with \texttt{[zgap]}
and will list the directory where \texttt{zgap} will store the files and
sockets it uses to communicate. In particular, the \texttt{logXX.txt} files
within that directory will contain the output generated by the workers;
+this is useful for debugging, as the workers do not have a working break loop.
+Example:
+\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
+ bin/zgap -N 4 -P 8 -m 1G common.g
+\end{Verbatim}
+ On NUMA architectures that support the \texttt{numactl} command, it is
possible to further specify which node each worker should be
+running on. This can take one of two forms:
+\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
+ bin/zgap -N <count>:<start>-<end>
+ bin/zgap -N <count>:+<start>-<end>
+\end{Verbatim}
+ Each will distribute \texttt{count} worker processes on the physical nodes
ranging from \texttt{start} to \texttt{end} in a round\texttt{\symbol{45}}robin
fashion, reusing nodes if there are more
+workers than nodes. The first mode (without a \texttt{+} sign) will use
absolute node numbers, the second will be relative to the
+master process. See the \texttt{numactl} manual page for further details.
Example:
+\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
+ bin/zgap -N 4:+0-3 -P 8 -m 1G common.g
+\end{Verbatim}
+ Note: Currently, \texttt{zgap} can only be run from the GAP root directory.
This is an implementation
+restriction that is to be removed at a later date. }
+
+
+\section{\textcolor{Chapter }{Zgap API}}\label{Zgap API}
+\logpage{[ 3, 2, 0 ]}
+\hyperdef{L}{X801F6BAD823982B7}{}
+{
+ Most of the following API functions take a \texttt{dest} argument, which is
used to specify the destination of the operation. To
+specify a worker thread, \texttt{dest} would have to be an integer in the
range from 1 to the number of worker
+processes; 0 specifies the master process. Multiple processes can be specified
+by a range or list of integers. The variable \texttt{ZAll} contains a range
encompassing the worker processes; \texttt{ZSelf} contains the index of the
current worker or 0 for the master.
+
+\subsection{\textcolor{Chapter }{ZExec}}
+\logpage{[ 3, 2, 1 ]}\nobreak
+\hyperdef{L}{X8551BAF585C80F26}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZExec({\mdseries\slshape
dest, cmd})\index{ZExec@\texttt{ZExec}}
+\label{ZExec}
+}\hfill{\scriptsize (function)}}\\
+
+
+ This function sends \texttt{cmd} to the given destination and executes it
there. The command must be a valid
+GAP statement ending in a semicolon. If \texttt{dest} specifies multiple
processes, the command will be executed on all of them. }
+
+
+
+\subsection{\textcolor{Chapter }{ZBind}}
+\logpage{[ 3, 2, 2 ]}\nobreak
+\hyperdef{L}{X7A8B812C86B04F6F}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZBind({\mdseries\slshape
dest, var, expr})\index{ZBind@\texttt{ZBind}}
+\label{ZBind}
+}\hfill{\scriptsize (function)}}\\
+
+
+ This function binds the global variable described by the string \texttt{var}
to the value \texttt{expr} in all processes listed in \texttt{dest}. Note that
\texttt{expr} must evaluate to a serializable value.
+\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
+ !gapprompt@gap>| !gapinput@ZBind(ZAll, "counter", 0);|
+\end{Verbatim}
+ }
+
+
+
+\subsection{\textcolor{Chapter }{ZUnbind}}
+\logpage{[ 3, 2, 3 ]}\nobreak
+\hyperdef{L}{X7F99C0288433A2B2}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZUnbind({\mdseries\slshape
dest, var})\index{ZUnbind@\texttt{ZUnbind}}
+\label{ZUnbind}
+}\hfill{\scriptsize (function)}}\\
+
+
+ This function is the counterpart to \texttt{ZBind}. It will unbind
\texttt{var} in all specified processes.
+\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
+ !gapprompt@gap>| !gapinput@ZUnbind(ZAll, "status");|
+\end{Verbatim}
+ }
+
+
+
+\subsection{\textcolor{Chapter }{ZCall}}
+\logpage{[ 3, 2, 4 ]}\nobreak
+\hyperdef{L}{X822FACEA7E675154}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZCall({\mdseries\slshape
dest, func, args})\index{ZCall@\texttt{ZCall}}
+\label{ZCall}
+}\hfill{\scriptsize (function)}}\\
+
+
+ This function will execute the function specified by the string \texttt{func}
in the specified processes. The string \texttt{func} must be the name of a
global variable referring to the function to be
+executed. This function should be created at startup by adding a file to the
+commandline that defines it in all workers or by \texttt{ZExec}.
+\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
+ !gapprompt@gap>| !gapinput@ZBind(ZAll, "counter", 0);|
+ !gapprompt@gap>| !gapinput@ZExec(Zall, "add := function(n) counter :=
counter + n; end;");|
+ !gapprompt@gap>| !gapinput@ZCall(1, "add", [1]);|
+\end{Verbatim}
+ }
+
+
+
+\subsection{\textcolor{Chapter }{ZQuery}}
+\logpage{[ 3, 2, 5 ]}\nobreak
+\hyperdef{L}{X878EFC17847C03F9}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZQuery({\mdseries\slshape
dest, func, args, callback})\index{ZQuery@\texttt{ZQuery}}
+\label{ZQuery}
+}\hfill{\scriptsize (function)}}\\
+
+
+ This function works like \texttt{ZCall}, except that any return value will be
passed to the callback function.
+\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
+ !gapprompt@gap>| !gapinput@res := false;|
+ false
+ !gapprompt@gap>| !gapinput@ZQuery(1, "ReturnTrue", [], function(x) res := x;
end);|
+ !gapprompt@gap>| !gapinput@res;|
+ true
+\end{Verbatim}
+ }
+
+
+
+\subsection{\textcolor{Chapter }{ZResponse}}
+\logpage{[ 3, 2, 6 ]}\nobreak
+\hyperdef{L}{X7F4D42487BF9D04D}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZResponse({\mdseries\slshape
})\index{ZResponse@\texttt{ZResponse}}
+\label{ZResponse}
+}\hfill{\scriptsize (function)}}\\
+
+
+ \texttt{ZResponse} is a convenience function to construct blocking callbacks
for \texttt{ZCall} and \texttt{ZTask}. It returns a record containing a
\texttt{put}, a \texttt{get}, and a \texttt{test} function. Here, \texttt{put}
is passed as the callback; \texttt{get} can be used to read the returned value;
and \texttt{test} can be used to test for the presence of a value.
+\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
+ !gapprompt@gap>| !gapinput@resp := ZResponse();;|
+ !gapprompt@gap>| !gapinput@ZQuery(1, "Z", [4], resp.put);|
+ !gapprompt@gap>| [email protected]();|
+ Z(2^2)
+ !gapprompt@gap>| [email protected]();|
+ true
+\end{Verbatim}
+ }
+
+
+
+\subsection{\textcolor{Chapter }{ZTask}}
+\logpage{[ 3, 2, 7 ]}\nobreak
+\hyperdef{L}{X7BC0A3AB859AC0A0}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZTask({\mdseries\slshape
dest, func, args, callback})\index{ZTask@\texttt{ZTask}}
+\label{ZTask}
+}\hfill{\scriptsize (function)}}\\
+
+
+ This function works like \texttt{ZQuery}, except that the function will be
executed via a task and \texttt{callback} will be called after the task
finishes and returns a result. }
+
+
+
+\subsection{\textcolor{Chapter }{ZAsync}}
+\logpage{[ 3, 2, 8 ]}\nobreak
+\hyperdef{L}{X8334DF718141DE22}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZAsync({\mdseries\slshape
dest, func, args})\index{ZAsync@\texttt{ZAsync}}
+\label{ZAsync}
+}\hfill{\scriptsize (function)}}\\
+
+
+ This function works like \texttt{ZCall}, except that the function will be
executed via a task. }
+
+
+
+\subsection{\textcolor{Chapter }{ZRead}}
+\logpage{[ 3, 2, 9 ]}\nobreak
+\hyperdef{L}{X87623A0F870BF0D9}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZRead({\mdseries\slshape
dest, file})\index{ZRead@\texttt{ZRead}}
+\label{ZRead}
+}\hfill{\scriptsize (function)}}\\
+
+
+ This function does a \texttt{Read(file)} for all specified processes. }
+
+
+
+\subsection{\textcolor{Chapter }{ZReadGapRoot}}
+\logpage{[ 3, 2, 10 ]}\nobreak
+\hyperdef{L}{X852FCB6F7D337E65}{}
+{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ZReadGapRoot({\mdseries\slshape
dest, file})\index{ZReadGapRoot@\texttt{ZReadGapRoot}}
+\label{ZReadGapRoot}
+}\hfill{\scriptsize (function)}}\\
+
+
+ This function does a \texttt{ReadGapRoot(file)} for all specified processes. }
+
+ }
+
+ }
+
+ {\nobreakspace} \def\indexname{Index\logpage{[ "Ind", 0, 0 ]}
+\hyperdef{L}{X83A0356F839C696F}{}
+}
+
+\cleardoublepage
+\phantomsection
+\addcontentsline{toc}{chapter}{Index}
+
+
+\printindex
+
+\immediate\write\pagenrlog{["Ind", 0, 0], \arabic{page},}
+\newpage
+\immediate\write\pagenrlog{["End"], \arabic{page}];}
+\immediate\closeout\pagenrlog
+\end{document}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' --exclude Makefile.in --exclude configure --exclude
config.guess --exclude '*.pot' --exclude mkinstalldirs --exclude aclocal.m4
--exclude config.sub --exclude depcomp --exclude install-sh --exclude ltmain.sh
old/ZeroMQInterface-0.17/doc/chap0.html new/ZeroMQInterface-0.18/doc/chap0.html
--- old/ZeroMQInterface-0.17/doc/chap0.html 2025-06-20 13:09:31.000000000
+0200
+++ new/ZeroMQInterface-0.18/doc/chap0.html 2026-04-09 02:00:00.000000000
+0200
@@ -29,10 +29,10 @@
<h2>ZeroMQ bindings for <strong class="pkg">GAP</strong></h2>
<p>
- 0.17</p>
+ 0.18</p>
<p>
- 20 June 2025
+ 9 April 2026
</p>
</div>
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' --exclude Makefile.in --exclude configure --exclude
config.guess --exclude '*.pot' --exclude mkinstalldirs --exclude aclocal.m4
--exclude config.sub --exclude depcomp --exclude install-sh --exclude ltmain.sh
old/ZeroMQInterface-0.17/doc/chap0.txt new/ZeroMQInterface-0.18/doc/chap0.txt
--- old/ZeroMQInterface-0.17/doc/chap0.txt 2025-06-20 13:09:24.000000000
+0200
+++ new/ZeroMQInterface-0.18/doc/chap0.txt 2026-04-09 02:00:00.000000000
+0200
@@ -6,10 +6,10 @@
[1X ZeroMQ bindings for [5XGAP[105X [101X
- 0.17
+ 0.18
- 20 June 2025
+ 9 April 2026
Markus Pfeiffer
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' --exclude Makefile.in --exclude configure --exclude
config.guess --exclude '*.pot' --exclude mkinstalldirs --exclude aclocal.m4
--exclude config.sub --exclude depcomp --exclude install-sh --exclude ltmain.sh
old/ZeroMQInterface-0.17/doc/chap0_mj.html
new/ZeroMQInterface-0.18/doc/chap0_mj.html
--- old/ZeroMQInterface-0.17/doc/chap0_mj.html 2025-06-20 13:09:31.000000000
+0200
+++ new/ZeroMQInterface-0.18/doc/chap0_mj.html 2026-04-09 02:00:00.000000000
+0200
@@ -32,10 +32,10 @@
<h2>ZeroMQ bindings for <strong class="pkg">GAP</strong></h2>
<p>
- 0.17</p>
+ 0.18</p>
<p>
- 20 June 2025
+ 9 April 2026
</p>
</div>
Binary files old/ZeroMQInterface-0.17/doc/manual.pdf and
new/ZeroMQInterface-0.18/doc/manual.pdf differ
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' --exclude Makefile.in --exclude configure --exclude
config.guess --exclude '*.pot' --exclude mkinstalldirs --exclude aclocal.m4
--exclude config.sub --exclude depcomp --exclude install-sh --exclude ltmain.sh
old/ZeroMQInterface-0.17/doc/title.xml new/ZeroMQInterface-0.18/doc/title.xml
--- old/ZeroMQInterface-0.17/doc/title.xml 2025-06-20 13:09:24.000000000
+0200
+++ new/ZeroMQInterface-0.18/doc/title.xml 2026-04-09 02:00:00.000000000
+0200
@@ -9,7 +9,7 @@
ZeroMQ bindings for &GAP;
</Subtitle>
<Version>
- 0.17
+ 0.18
</Version>
<Author>
Markus Pfeiffer<Alt Only="LaTeX"><Br/></Alt>
@@ -38,7 +38,7 @@
</Author>
<Date>
- 20 June 2025
+ 9 April 2026
</Date>
<Copyright>
©right; 2015-17 by Markus Pfeiffer, Reimer Behrends and others<P/>
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' --exclude Makefile.in --exclude configure --exclude
config.guess --exclude '*.pot' --exclude mkinstalldirs --exclude aclocal.m4
--exclude config.sub --exclude depcomp --exclude install-sh --exclude ltmain.sh
old/ZeroMQInterface-0.17/gap/znode.g new/ZeroMQInterface-0.18/gap/znode.g
--- old/ZeroMQInterface-0.17/gap/znode.g 2025-06-20 13:09:01.000000000
+0200
+++ new/ZeroMQInterface-0.18/gap/znode.g 2026-04-09 02:00:00.000000000
+0200
@@ -215,8 +215,8 @@
put := function(result)
SyncWrite(response, MakeReadOnlyObj(result));
end,
- get := -> SyncRead(response),
- test := -> SyncIsBound(response),
+ get := {} -> SyncRead(response),
+ test := {} -> SyncIsBound(response),
));
end;
++++++ _scmsync.obsinfo ++++++
--- /var/tmp/diff_new_pack.nHaFqa/_old 2026-04-10 18:03:32.163904327 +0200
+++ /var/tmp/diff_new_pack.nHaFqa/_new 2026-04-10 18:03:32.167904492 +0200
@@ -1,5 +1,5 @@
-mtime: 1750421287
-commit: 7e4da15e8b574745e127e0403bf168eff4918b5a50564fb568aba2da74e5abdf
+mtime: 1775811725
+commit: 0e855ac77da4da96aab74758fed8e01706e7d5bd44d356b3177fa2935727f857
url: https://src.opensuse.org/jengelh/gap-zeromqinterface
revision: master
++++++ build.specials.obscpio ++++++
++++++ build.specials.obscpio ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/.gitignore new/.gitignore
--- old/.gitignore 1970-01-01 01:00:00.000000000 +0100
+++ new/.gitignore 2026-04-10 11:02:15.000000000 +0200
@@ -0,0 +1 @@
+.osc
