//  Reading from multiple sockets
//  This version uses a simple recv loop

#include "zhelpers.h"

int main (void) 
{
    //  Connect to task ventilator
    void *context = zmq_ctx_new ();
    void *receiver = zmq_socket (context, ZMQ_PULL);
    zmq_connect (receiver, "tcp://localhost:5557");

    //  Connect to weather server
    void *subscriber = zmq_socket (context, ZMQ_SUB);
    zmq_connect (subscriber, "tcp://localhost:5556");
    zmq_setsockopt (subscriber, ZMQ_SUBSCRIBE, "10001 ", 6);

    //  Process messages from both sockets
    //  We prioritize traffic from the task ventilator
    while (1) {
        char msg [256];
        while (1) {
            int size = zmq_recv (receiver, msg, 255, ZMQ_DONTWAIT);
            if (size != -1) {
                //  Process task
            }
            else
                break;
        }
        while (1) {
            int size = zmq_recv (subscriber, msg, 255, ZMQ_DONTWAIT);
            if (size != -1) {
                //  Process weather update
            }
            else
                break;
        }
        //  No activity, so sleep for 1 msec
        s_sleep (1);
    }
    zmq_close (receiver);
    zmq_close (subscriber);
    zmq_ctx_destroy (context);
    return 0;
}

//
//  Reading from multiple sockets in C++
//  This version uses a simple recv loop
//


#include "zhelpers.hpp"


int main (int argc, char *argv[])
{
    //  Prepare our context and sockets
    zmq::context_t context(1);

    //  Connect to task ventilator
    zmq::socket_t receiver(context, ZMQ_PULL);
    receiver.connect("tcp://localhost:5557");

    //  Connect to weather server
    zmq::socket_t subscriber(context, ZMQ_SUB);
    subscriber.connect("tcp://localhost:5556");
    subscriber.set(zmq::sockopt::subscribe, "10001 ");

    //  Process messages from both sockets
    //  We prioritize traffic from the task ventilator
    while (1) {
    	
        //  Process any waiting tasks
        bool rc;
        do {
            zmq::message_t task;
            if ((rc = receiver.recv(&task, ZMQ_DONTWAIT)) == true) {
                //  process task
            }
        } while(rc == true);
        
        //  Process any waiting weather updates
        do {
            zmq::message_t update;
            if ((rc = subscriber.recv(&update, ZMQ_DONTWAIT)) == true) {
                //  process weather update

            }
        } while(rc == true);
        
        //  No activity, so sleep for 1 msec
        s_sleep(1);
    }
    return 0;
}

;;; -*- Mode:Lisp; Syntax:ANSI-Common-Lisp; -*-
;;;
;;;  Reading from multiple sockets in Common Lisp
;;;  This version uses a simple recv loop
;;;
;;; Kamil Shakirov <kamils80@gmail.com>
;;;

(defpackage #:zguide.msreader
  (:nicknames #:msreader)
  (:use #:cl #:zhelpers)
  (:export #:main))

(in-package :zguide.msreader)

(defun main ()
  ;; Prepare our context and socket
  (zmq:with-context (context 1)
    ;; Connect to task ventilator
    (zmq:with-socket (receiver context zmq:pull)
      (zmq:connect receiver "tcp://localhost:5557")
      ;; Connect to weather server
      (zmq:with-socket (subscriber context zmq:sub)
        (zmq:connect subscriber "tcp://localhost:5556")
        (zmq:setsockopt subscriber zmq:subscribe "10001 ")

        ;; Process messages from both sockets
        ;; We prioritize traffic from the task ventilator
        (loop
          (handler-case
              (loop
                (let ((task (make-instance 'zmq:msg)))
                  (zmq:recv receiver task zmq:noblock)
                  ;; process task
                  (dump-message task)
                  (finish-output)))

            (zmq:error-again () nil))

          ;; Process any waiting weather updates
          (handler-case
              (loop
                (let ((update (make-instance 'zmq:msg)))
                  (zmq:recv subscriber update zmq:noblock)
                  ;; process weather update
                  (dump-message update)
                  (finish-output)))

            (zmq:error-again () nil))

          ;; No activity, so sleep for 1 msec
          (isys:usleep 1000)))))

  (cleanup))

#! /usr/bin/env escript
%%
%% Reading from multiple sockets
%% This version uses a simple recv loop
%%

main(_) ->
    %% Prepare our context and sockets
    {ok, Context} = erlzmq:context(),

    %% Connect to task ventilator
    {ok, Receiver} = erlzmq:socket(Context, pull),
    ok = erlzmq:connect(Receiver, "tcp://localhost:5557"),

    %% Connect to weather server
    {ok, Subscriber} = erlzmq:socket(Context, sub),
    ok = erlzmq:connect(Subscriber, "tcp://localhost:5556"),
    ok = erlzmq:setsockopt(Subscriber, subscribe, <<"10001">>),

    %% Process messages from both sockets
    loop(Receiver, Subscriber),

    %% We never get here but clean up anyhow
    ok = erlzmq:close(Receiver),
    ok = erlzmq:close(Subscriber),
    ok = erlzmq:term(Context).

loop(Receiver, Subscriber) ->
    %% We prioritize traffic from the task ventilator
    process_tasks(Receiver),
    process_weather(Subscriber),
    timer:sleep(1000),
    loop(Receiver, Subscriber).

process_tasks(S) ->
    %% Process any waiting tasks
    case erlzmq:recv(S, [noblock]) of
        {error, eagain} -> ok;
        {ok, Msg} ->
            io:format("Procesing task: ~s~n", [Msg]),
            process_tasks(S)
    end.

process_weather(S) ->
    %% Process any waiting weather updates
    case erlzmq:recv(S, [noblock]) of
        {error, eagain} -> ok;
        {ok, Msg} ->
            io:format("Processing weather update: ~s~n", [Msg]),
            process_weather(S)
    end.

defmodule Msreader do
  @moduledoc """
  Generated by erl2ex (http://github.com/dazuma/erl2ex)
  From Erlang source: (Unknown source file)
  At: 2019-12-20 13:57:27

  """

  def main() do
    {:ok, context} = :erlzmq.context()
    {:ok, receiver} = :erlzmq.socket(context, :pull)
    :ok = :erlzmq.connect(receiver, 'tcp://localhost:5557')
    {:ok, subscriber} = :erlzmq.socket(context, :sub)
    :ok = :erlzmq.connect(subscriber, 'tcp://localhost:5556')
    :ok = :erlzmq.setsockopt(subscriber, :subscribe, "10001")
    loop(receiver, subscriber)
    :ok = :erlzmq.close(receiver)
    :ok = :erlzmq.close(subscriber)
    :ok = :erlzmq.term(context)
  end


  def loop(receiver, subscriber) do
    process_tasks(receiver)
    process_weather(subscriber)
    :timer.sleep(1000)
    loop(receiver, subscriber)
  end

  #case(:erlzmq.recv(s, [:noblock])) do

  def process_tasks(s) do
    case(:erlzmq.recv(s, [:dontwait])) do
      {:error, :eagain} ->
        :ok
      {:ok, msg} ->
        :io.format('Procesing task: ~s~n', [msg])
        process_tasks(s)
    end
  end


  def process_weather(s) do
    case(:erlzmq.recv(s, [:dontwait])) do
      {:error, :eagain} ->
        :ok
      {:ok, msg} ->
        :io.format('Processing weather update: ~s~n', [msg])
        process_weather(s)
    end
  end

end

Msreader.main

//
// Reading from multiple sockets 
// This version uses a simple recv loop
//
package main

import (
	"fmt"
	zmq "github.com/alecthomas/gozmq"
	"time"
)

func main() {

	context, _ := zmq.NewContext()
	defer context.Close()

	//  Connect to task ventilator
	receiver, _ := context.NewSocket(zmq.PULL)
	defer receiver.Close()
	receiver.Connect("tcp://localhost:5557")

	//  Connect to weather server
	subscriber, _ := context.NewSocket(zmq.SUB)
	defer subscriber.Close()
	subscriber.Connect("tcp://localhost:5556")
	subscriber.SetSubscribe("10001")

	//  Process messages from both sockets
	//  We prioritize traffic from the task ventilator
	for {

		// ventilator
		for b, _ := receiver.Recv(zmq.NOBLOCK); b != nil; {
			// fake process task
		}

		// weather server
		for b, _ := subscriber.Recv(zmq.NOBLOCK); b != nil; {
			//  process task
			fmt.Printf("found weather =%s\n", string(b))
		}

		//  No activity, so sleep for 1 msec
		time.Sleep(1e6)
	}

	fmt.Println("done")

}

package guide;

import org.zeromq.SocketType;
import org.zeromq.ZMQ;
import org.zeromq.ZContext;

//
//  Reading from multiple sockets in Java
//  This version uses a simple recv loop
//
public class msreader
{

    public static void main(String[] args) throws Exception
    {
        //  Prepare our context and sockets
        try (ZContext context = new ZContext()) {
            // Connect to task ventilator
            ZMQ.Socket receiver = context.createSocket(SocketType.PULL);
            receiver.connect("tcp://localhost:5557");

            //  Connect to weather server
            ZMQ.Socket subscriber = context.createSocket(SocketType.SUB);
            subscriber.connect("tcp://localhost:5556");
            subscriber.subscribe("10001 ".getBytes(ZMQ.CHARSET));

            //  Process messages from both sockets
            //  We prioritize traffic from the task ventilator
            while (!Thread.currentThread().isInterrupted()) {
                //  Process any waiting tasks
                byte[] task;
                while ((task = receiver.recv(ZMQ.DONTWAIT)) != null) {
                    System.out.println("process task");
                }
                //  Process any waiting weather updates
                byte[] update;
                while ((update = subscriber.recv(ZMQ.DONTWAIT)) != null) {
                    System.out.println("process weather update");
                }
                //  No activity, so sleep for 1 msec
                Thread.sleep(1000);
            }
        }
    }
}

#!/usr/bin/env julia

# Reading from multiple sockets

# The ZMQ.jl wrapper implements ZMQ.recv as a blocking function. Nonblocking i/o
# in Julia is typically done using coroutines (Tasks).
# The @async macro puts its enclosed expression in a Task. When the macro is
# executed, its Task gets scheduled and execution continues immediately to
# whatever follows the macro.

# Note: the msreader example in the zguide is presented as a "dirty hack"
# using the ZMQ_DONTWAIT and EAGAIN codes. Since the ZMQ.jl wrapper API
# does not expose DONTWAIT directly, this example skips the hack and instead
# provides an efficient solution.

using ZMQ

# Prepare our context and sockets
context = ZMQ.Context()

# Connect to task ventilator
receiver = Socket(context, ZMQ.PULL)
ZMQ.connect(receiver, "tcp://localhost:5557")

# Connect to weather server
subscriber = Socket(context,ZMQ.SUB)
ZMQ.connect(subscriber,"tcp://localhost:5556")
ZMQ.set_subscribe(subscriber, "10001")

while true

    # Process any waiting tasks
    @async begin
        msg = unsafe_string(ZMQ.recv(receiver))
        println(msg)
    end

    # Process any waiting weather updates
    @async begin
        msg = unsafe_string(ZMQ.recv(subscriber))
        println(msg)
    end

    # Sleep for 1 msec
    sleep(0.001)
end

--
--  Reading from multiple sockets
--  This version uses a simple recv loop
--
--  Author: Robert G. Jakabosky <bobby@sharedrealm.com>
--
require"zmq"
require"zhelpers"

--  Prepare our context and sockets
local context = zmq.init(1)

--  Connect to task ventilator
local receiver = context:socket(zmq.PULL)
receiver:connect("tcp://localhost:5557")

--  Connect to weather server
local subscriber = context:socket(zmq.SUB)
subscriber:connect("tcp://localhost:5556")
subscriber:setopt(zmq.SUBSCRIBE, "10001 ")

--  Process messages from both sockets
--  We prioritize traffic from the task ventilator
while true do
    --  Process any waiting tasks
    local msg
    while true do
        msg = receiver:recv(zmq.NOBLOCK)
        if not msg then break end
        --  process task
    end
    --  Process any waiting weather updates
    while true do
        msg = subscriber:recv(zmq.NOBLOCK)
        if not msg then break end
        --  process weather update
    end
    --  No activity, so sleep for 1 msec
    s_sleep (1)
end
--  We never get here but clean up anyhow
receiver:close()
subscriber:close()
context:term()

/* msreader.m: Reads from multiple sockets the hard way.
 * *** DON'T DO THIS - see mspoller.m for a better example. *** */
#import "ZMQObjC.h"

static NSString *const kTaskVentEndpoint = @"tcp://localhost:5557";
static NSString *const kWeatherServerEndpoint = @"tcp://localhost:5556";
#define MSEC_PER_NSEC (1000000)

int
main(void)
{
	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
	ZMQContext *ctx = [[[ZMQContext alloc] initWithIOThreads:1U] autorelease];

	/* Connect to task ventilator. */
	ZMQSocket *receiver = [ctx socketWithType:ZMQ_PULL];
	[receiver connectToEndpoint:kTaskVentEndpoint];

	/* Connect to weather server. */
	ZMQSocket *subscriber = [ctx socketWithType:ZMQ_SUB];
	[subscriber connectToEndpoint:kWeatherServerEndpoint];
	NSData *subData = [@"10001" dataUsingEncoding:NSUTF8StringEncoding];
	[subscriber setData:subData forOption:ZMQ_SUBSCRIBE];

	/* Process messages from both sockets, prioritizing the task vent. */
	/* Could fair queue by checking each socket for activity in turn, rather
	 * than continuing to service the current socket as long as it is busy. */
	struct timespec msec = {0, MSEC_PER_NSEC};
	for (;;) {
		/* Worst case: a task is always pending and we never get to weather,
		 * or vice versa. In such a case, memory use would rise without
		 * limit if we did not ensure the objects autoreleased by a single loop
		 * will be autoreleased whether we leave or continue in the loop. */
		NSAutoreleasePool *p;

		/* Process any waiting tasks. */
		for (p = [[NSAutoreleasePool alloc] init];
				nil != [receiver receiveDataWithFlags:ZMQ_NOBLOCK];
				[p drain], p = [[NSAutoreleasePool alloc] init]);
		[p drain];

		/* No waiting tasks - process any waiting weather updates. */
		for (p = [[NSAutoreleasePool alloc] init];
				nil != [subscriber receiveDataWithFlags:ZMQ_NOBLOCK];
				[p drain], p = [[NSAutoreleasePool alloc] init]);
		[p drain];

		/* Nothing doing - sleep for a millisecond. */
		(void)nanosleep(&msec, NULL);
	}

	/* NOT REACHED */
	[ctx closeSockets];
	[pool drain];  /* This finally releases the autoreleased context. */
	return EXIT_SUCCESS;
}

# Reading from multiple sockets in Perl
# This version uses a simple recv loop

use strict;
use warnings;
use v5.10;

use ZMQ::FFI;
use ZMQ::FFI::Constants qw(ZMQ_PULL ZMQ_SUB ZMQ_DONTWAIT);

use TryCatch;
use Time::HiRes qw(usleep);

# Connect to task ventilator
my $context = ZMQ::FFI->new();
my $receiver = $context->socket(ZMQ_PULL);
$receiver->connect('tcp://localhost:5557');

# Connect to weather server
my $subscriber = $context->socket(ZMQ_SUB);
$subscriber->connect('tcp://localhost:5556');
$subscriber->subscribe('10001');

# Process messages from both sockets
# We prioritize traffic from the task ventilator
while (1) {

    PROCESS_TASK:
    while (1) {
        try {
            my $msg = $receiver->recv(ZMQ_DONTWAIT);
            # Process task
        }
        catch {
            last PROCESS_TASK;
        }
    }

    PROCESS_UPDATE:
    while (1) {
        try {
            my $msg = $subscriber->recv(ZMQ_DONTWAIT);
            # Process weather update
        }
        catch {
            last PROCESS_UPDATE;
        }
    }

    # No activity, so sleep for 1 msec
    usleep(1000);
}

<?php
/*
 *  Reading from multiple sockets
 *  This version uses a simple recv loop
 * @author Ian Barber <ian(dot)barber(at)gmail(dot)com>
 */

//  Prepare our context and sockets
$context = new ZMQContext();

//  Connect to task ventilator
$receiver = new ZMQSocket($context, ZMQ::SOCKET_PULL);
$receiver->connect("tcp://localhost:5557");

//  Connect to weather server
$subscriber = new ZMQSocket($context, ZMQ::SOCKET_SUB);
$subscriber->connect("tcp://localhost:5556");
$subscriber->setSockOpt(ZMQ::SOCKOPT_SUBSCRIBE, "10001");

//  Process messages from both sockets
//  We prioritize traffic from the task ventilator
while (true) {
    //  Process any waiting tasks
    try {
        for ($rc = 0; !$rc;) {
            if ($rc = $receiver->recv(ZMQ::MODE_NOBLOCK)) {
                // process task
            }
        }
    } catch (ZMQSocketException $e) {
        // do nothing
    }

    try {
        //  Process any waiting weather updates
        for ($rc = 0; !$rc;) {
            if ($rc = $subscriber->recv(ZMQ::MODE_NOBLOCK)) {
                // process weather update
            }
        }
    } catch (ZMQSocketException $e) {
        // do nothing
    }

    //  No activity, so sleep for 1 msec
    usleep(1);
}

# encoding: utf-8
#
#   Reading from multiple sockets
#   This version uses a simple recv loop
#
#   Author: Jeremy Avnet (brainsik) <spork(dash)zmq(at)theory(dot)org>
#

import zmq
import time

# Prepare our context and sockets
context = zmq.Context()

# Connect to task ventilator
receiver = context.socket(zmq.PULL)
receiver.connect("tcp://localhost:5557")

# Connect to weather server
subscriber = context.socket(zmq.SUB)
subscriber.connect("tcp://localhost:5556")
subscriber.setsockopt(zmq.SUBSCRIBE, b"10001")

# Process messages from both sockets
# We prioritize traffic from the task ventilator
while True:

    # Process any waiting tasks
    while True:
        try:
            msg = receiver.recv(zmq.DONTWAIT)
        except zmq.Again:
            break
        # process task

    # Process any waiting weather updates
    while True:
        try:
            msg = subscriber.recv(zmq.DONTWAIT)
        except zmq.Again:
            break
        # process weather update

    # No activity, so sleep for 1 msec
    time.sleep(0.001)

#!/usr/bin/env ruby

# author: Oleg Sidorov <4pcbr> i4pcbr@gmail.com
# this code is licenced under the MIT/X11 licence.
#
# Reading from multiple sockets
# This version uses a simple recv loop

require 'rubygems'
require 'ffi-rzmq'

context = ZMQ::Context.new

# Connect to task ventilator
receiver = context.socket(ZMQ::PULL)
receiver.connect('tcp://localhost:5557')

# Connect to weather server
subscriber = context.socket(ZMQ::SUB)
subscriber.connect('tcp://localhost:5556')
subscriber.setsockopt(ZMQ::SUBSCRIBE, '10001')

while true
  if receiver.recv_string(receiver_msg = '',ZMQ::NOBLOCK) && !receiver_msg.empty?
    # process task
    puts "receiver: #{receiver_msg}"
  end

  if subscriber.recv_string(subscriber_msg = '',ZMQ::NOBLOCK) && !subscriber_msg.empty?
    # process weather update
    puts "weather: #{subscriber_msg}"
  end

  # No activity, so sleep for 1 msec
  sleep 0.001
end

use std::{thread, time};

fn main() {
    let context = zmq::Context::new();
    let receiver = context.socket(zmq::PULL).unwrap();
    assert!(receiver.connect("tcp://localhost:5557").is_ok());

    let subscriber = context.socket(zmq::SUB).unwrap();
    assert!(subscriber.connect("tcp://localhost:5556").is_ok());
    assert!(subscriber.set_subscribe(b"10001").is_ok());

    loop {
        loop {
            if receiver.recv_msg(zmq::DONTWAIT).is_err() {
                break;
            }
        }
        loop {
            if subscriber.recv_msg(zmq::DONTWAIT).is_err() {
                break;
            }
        }
        thread::sleep(time::Duration::from_millis(1));
    }
}

/*
 *
 *  Reading from multiple sockets in Scala
 *  This version uses a simple recv loop
 *
 * @author Giovanni Ruggiero
 * @email giovanni.ruggiero@gmail.com
 */

import org.zeromq.ZMQ

object msreader {
  def main(args : Array[String]) {

		//  Prepare our context and sockets
		val context = ZMQ.context(1)

		// Connect to task ventilator
		val receiver = context.socket(ZMQ.PULL)
		receiver.connect("tcp://localhost:5557")

		//  Connect to weather server
		val subscriber = context.socket(ZMQ.SUB)
		subscriber.connect("tcp://localhost:5556")
		subscriber.subscribe("10001 ".getBytes())

		//  Process messages from both sockets
		//  We prioritize traffic from the task ventilator
		while (true) {
			//  Process any waiting tasks
			val task = receiver.recv(ZMQ.NOBLOCK)
			while(task != null) {
				//  process task
			}
			//  Process any waiting weather updates
			val update = subscriber.recv(ZMQ.NOBLOCK)
			while (update != null) {
				//  process weather update
			}
			//  No activity, so sleep for 1 msec
			Thread.sleep(1)
		}
	}
}

#
# Reading from multiple sockets
# This version uses a simple recv loop
#

package require zmq

# Prepare our context and sockets
zmq context context

# Connect to task ventilator
zmq socket receiver context PULL
receiver connect "tcp://localhost:5557"

# Connect to weather server
zmq socket subscriber context SUB
subscriber connect "tcp://*:5556"
subscriber setsockopt SUBSCRIBE "10001"

# Socket to send messages to
zmq socket sender context PUSH
sender connect "tcp://localhost:5558"

# Process messages from both sockets
# We prioritize traffic from the task ventilator
while {1} {
    # Process any waiting task
    for {set rc 0} {!$rc} {} {
	zmq message task
	if {[set rc [receiver recv_msg task NOBLOCK]] == 0} {
	    # Do the work
	    set string [task data]
	    puts "Process task: $string"
	    after $string
	    # Send result to sink
	    sender send "$string"
	}
	task close
    }
    # Process any waiting weather update
    for {set rc 0} {!$rc} {} {
	zmq message msg
	if {[set rc [subscriber recv_msg msg NOBLOCK]] == 0} {
	    puts "Weather update: [msg data]"
	}
	msg close
    }
    # No activity, sleep for 1 msec
    after 1
}

# We never get here but clean up anyhow
sender close
receiver close
subscriber close
context term

//  Reading from multiple sockets
//  This version uses zmq_poll()

#include "zhelpers.h"

int main (void) 
{
    //  Connect to task ventilator
    void *context = zmq_ctx_new ();
    void *receiver = zmq_socket (context, ZMQ_PULL);
    zmq_connect (receiver, "tcp://localhost:5557");

    //  Connect to weather server
    void *subscriber = zmq_socket (context, ZMQ_SUB);
    zmq_connect (subscriber, "tcp://localhost:5556");
    zmq_setsockopt (subscriber, ZMQ_SUBSCRIBE, "10001 ", 6);

    zmq_pollitem_t items [] = {
        { receiver,   0, ZMQ_POLLIN, 0 },
        { subscriber, 0, ZMQ_POLLIN, 0 }
    };
    //  Process messages from both sockets
    while (1) {
        char msg [256];

        zmq_poll (items, 2, -1);
        if (items [0].revents & ZMQ_POLLIN) {
            int size = zmq_recv (receiver, msg, 255, 0);
            if (size != -1) {
                //  Process task
            }
        }
        if (items [1].revents & ZMQ_POLLIN) {
            int size = zmq_recv (subscriber, msg, 255, 0);
            if (size != -1) {
                //  Process weather update
            }
        }
    }
    zmq_close (subscriber);
    zmq_ctx_destroy (context);
    return 0;
}

//
//  Reading from multiple sockets in C++
//  This version uses zmq_poll()
//

#include "zhelpers.hpp"


int main (int argc, char *argv[])
{
    zmq::context_t context(1);

    //  Connect to task ventilator
    zmq::socket_t receiver(context, ZMQ_PULL);
    receiver.connect("tcp://localhost:5557");

    //  Connect to weather server
    zmq::socket_t subscriber(context, ZMQ_SUB);
	subscriber.connect("tcp://localhost:5556");
    subscriber.set(zmq::sockopt::subscribe, "10001 ");

    //  Initialize poll set
    zmq::pollitem_t items [] = {
        { receiver, 0, ZMQ_POLLIN, 0 },
        { subscriber, 0, ZMQ_POLLIN, 0 }
    };
    //  Process messages from both sockets
    while (1) {
        zmq::message_t message;
        zmq::poll (&items [0], 2, -1);
        
        if (items [0].revents & ZMQ_POLLIN) {
            receiver.recv(&message);
            //  Process task
        }
        if (items [1].revents & ZMQ_POLLIN) {
            subscriber.recv(&message);
            //  Process weather update
        }
    }
    return 0;
}

;;; -*- Mode:Lisp; Syntax:ANSI-Common-Lisp; -*-
;;;
;;;  Reading from multiple sockets in Common Lisp
;;;  This version uses zmq_poll()
;;;
;;; Kamil Shakirov <kamils80@gmail.com>
;;;

(defpackage #:zguide.mspoller
  (:nicknames #:mspoller)
  (:use #:cl #:zhelpers)
  (:export #:main))

(in-package :zguide.mspoller)

(defun main ()
  (zmq:with-context (context 1)
    ;; Connect to task ventilator
    (zmq:with-socket (receiver context zmq:pull)
      (zmq:connect receiver "tcp://localhost:5557")
      ;; Connect to weather server
      (zmq:with-socket (subscriber context zmq:sub)
        (zmq:connect subscriber "tcp://localhost:5556")
        (zmq:setsockopt subscriber zmq:subscribe "10001 ")

        ;; Initialize poll set
        (zmq:with-polls ((items . ((receiver   . zmq:pollin)
                                   (subscriber . zmq:pollin))))
          ;; Process messages from both sockets
          (loop
            (let ((revents (zmq:poll items)))
              (when (= (first revents) zmq:pollin)
                (let ((message (make-instance 'zmq:msg)))
                  (zmq:recv receiver message)
                  ;; Process task
                  (dump-message message)
                  (finish-output)))

              (when (= (second revents) zmq:pollin)
                (let ((message (make-instance 'zmq:msg)))
                  (zmq:recv subscriber message)
                  ;; Process weather update
                  (dump-message message)
                  (finish-output)))))))))

  (cleanup))

#! /usr/bin/env escript
%%
%% Reading from multiple sockets
%% This version uses active sockets
%%

main(_) ->
    {ok,Context} = erlzmq:context(),

    %% Connect to task ventilator
    {ok, Receiver} = erlzmq:socket(Context, [pull, {active, true}]),
    ok = erlzmq:connect(Receiver, "tcp://localhost:5557"),

    %% Connect to weather server
    {ok, Subscriber} = erlzmq:socket(Context, [sub, {active, true}]),
    ok = erlzmq:connect(Subscriber, "tcp://localhost:5556"),
    ok = erlzmq:setsockopt(Subscriber, subscribe, <<"10001">>),

    %% Process messages from both sockets
    loop(Receiver, Subscriber),

    %% We never get here
    ok = erlzmq:close(Receiver),
    ok = erlzmq:close(Subscriber),
    ok = erlzmq:term(Context).

loop(Tasks, Weather) ->
    receive
        {zmq, Tasks, Msg, _Flags} ->
            io:format("Processing task: ~s~n",[Msg]),
            loop(Tasks, Weather);
        {zmq, Weather, Msg, _Flags} ->
            io:format("Processing weather update: ~s~n",[Msg]),
            loop(Tasks, Weather)
    end.

defmodule Mspoller do
  @moduledoc """
  Generated by erl2ex (http://github.com/dazuma/erl2ex)
  From Erlang source: (Unknown source file)
  At: 2019-12-20 13:57:27

  """

  def main() do
    {:ok, context} = :erlzmq.context()
    {:ok, receiver} = :erlzmq.socket(context, [:pull, {:active, true}])
    :ok = :erlzmq.connect(receiver, 'tcp://localhost:5557')
    {:ok, subscriber} = :erlzmq.socket(context, [:sub, {:active, true}])
    :ok = :erlzmq.connect(subscriber, 'tcp://localhost:5556')
    :ok = :erlzmq.setsockopt(subscriber, :subscribe, "10001")
    loop(receiver, subscriber)
    :ok = :erlzmq.close(receiver)
    :ok = :erlzmq.close(subscriber)
    :ok = :erlzmq.term(context)
  end


  def loop(tasks, weather) do
    receive do
      {:zmq, ^tasks, msg, _flags} ->
        :io.format('Processing task: ~s~n', [msg])
        loop(tasks, weather)
      {:zmq, ^weather, msg, _flags} ->
        :io.format('Processing weather update: ~s~n', [msg])
        loop(tasks, weather)
    end
  end

end

Mspoller.main

//
// Reading from multiple sockets 
// This version uses zmq.Poll()
//
package main

import (
	"fmt"
	zmq "github.com/alecthomas/gozmq"
)

func main() {

	context, _ := zmq.NewContext()
	defer context.Close()

	//  Connect to task ventilator
	receiver, _ := context.NewSocket(zmq.PULL)
	defer receiver.Close()
	receiver.Connect("tcp://localhost:5557")

	//  Connect to weather server
	subscriber, _ := context.NewSocket(zmq.SUB)
	defer subscriber.Close()
	subscriber.Connect("tcp://localhost:5556")
	subscriber.SetSubscribe("10001")

	pi := zmq.PollItems{
		zmq.PollItem{Socket: receiver, Events: zmq.POLLIN},
		zmq.PollItem{Socket: subscriber, Events: zmq.POLLIN},
	}

	//  Process messages from both sockets
	for {

		_, _ = zmq.Poll(pi, -1)

		switch {
		case pi[0].REvents&zmq.POLLIN != 0:
			//  Process task
			pi[0].Socket.Recv(0) // eat the incoming message
		case pi[1].REvents&zmq.POLLIN != 0:
			//  Process weather update
			pi[1].Socket.Recv(0) // eat the incoming message
		}

	}

	fmt.Println("done")

}

{-# LANGUAGE OverloadedStrings #-}

--  Reading from multiple sockets
--  This version uses zmq_poll()

module Main where

import Control.Monad
import System.ZMQ4.Monadic

main :: IO ()
main = runZMQ $ do
    -- Connect to task ventilator
    receiver <- socket Pull
    connect receiver "tcp://localhost:5557"

    -- Connect to weather server
    subscriber <- socket Sub
    connect subscriber "tcp://localhost:5556"
    subscribe subscriber "10001 "

    -- Process messages from both sockets
    forever $
        poll (-1) [ Sock receiver   [In] (Just receiver_callback)
                  , Sock subscriber [In] (Just subscriber_callback)
                  ]
  where
    -- Process task
    receiver_callback :: [Event] -> ZMQ z ()
    receiver_callback _ = return ()

    -- Process weather update
    subscriber_callback :: [Event] -> ZMQ z ()
    subscriber_callback _ = return ()

package guide;

import org.zeromq.SocketType;
import org.zeromq.ZMQ;
import org.zeromq.ZContext;

//
//  Reading from multiple sockets in Java
//  This version uses ZMQ.Poller
//
public class mspoller
{

    public static void main(String[] args)
    {
        try (ZContext context = new ZContext()) {
            // Connect to task ventilator
            ZMQ.Socket receiver = context.createSocket(SocketType.PULL);
            receiver.connect("tcp://localhost:5557");

            //  Connect to weather server
            ZMQ.Socket subscriber = context.createSocket(SocketType.SUB);
            subscriber.connect("tcp://localhost:5556");
            subscriber.subscribe("10001 ".getBytes(ZMQ.CHARSET));

            //  Initialize poll set
            ZMQ.Poller items = context.createPoller(2);
            items.register(receiver, ZMQ.Poller.POLLIN);
            items.register(subscriber, ZMQ.Poller.POLLIN);

            //  Process messages from both sockets
            while (!Thread.currentThread().isInterrupted()) {
                byte[] message;
                items.poll();
                if (items.pollin(0)) {
                    message = receiver.recv(0);
                    System.out.println("Process task");
                }
                if (items.pollin(1)) {
                    message = subscriber.recv(0);
                    System.out.println("Process weather update");
                }
            }
        }
    }
}

--
--  Reading from multiple sockets
--  This version uses :poll()
--
--  Author: Robert G. Jakabosky <bobby@sharedrealm.com>
--
require"zmq"
require"zmq.poller"
require"zhelpers"

local context = zmq.init(1)

--  Connect to task ventilator
local receiver = context:socket(zmq.PULL)
receiver:connect("tcp://localhost:5557")

--  Connect to weather server
local subscriber = context:socket(zmq.SUB)
subscriber:connect("tcp://localhost:5556")
subscriber:setopt(zmq.SUBSCRIBE, "10001 ", 6)

local poller = zmq.poller(2)

poller:add(receiver, zmq.POLLIN, function()
    local msg = receiver:recv()
    --  Process task
end)

poller:add(subscriber, zmq.POLLIN, function()
    local msg = subscriber:recv()
    --  Process weather update
end)

--  Process messages from both sockets
-- start poller's event loop
poller:start()

--  We never get here
receiver:close()
subscriber:close()
context:term()

// Reading from multiple sockets.
// This version listens for emitted 'message' events.

var zmq = require('zeromq')

// Connect to task ventilator
var receiver = zmq.socket('pull')

receiver.on('message', function(msg) {
  console.log("From Task Ventilator:", msg.toString())
})

// Connect to weather server.
var subscriber = zmq.socket('sub')

subscriber.subscribe('10001')
subscriber.on('message', function(msg) {
  console.log("Weather Update:", msg.toString())
})

receiver.connect('tcp://localhost:5557')
subscriber.connect('tcp://localhost:5556')

/* msreader.m: Reads from multiple sockets the right way. */
#import "ZMQObjC.h"

static NSString *const kTaskVentEndpoint = @"tcp://localhost:5557";
static NSString *const kWeatherServerEndpoint = @"tcp://localhost:5556";

int
main(void)
{
	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
	ZMQContext *ctx = [[[ZMQContext alloc] initWithIOThreads:1U] autorelease];

	/* Connect to task ventilator. */
	ZMQSocket *receiver = [ctx socketWithType:ZMQ_PULL];
	[receiver connectToEndpoint:kTaskVentEndpoint];

	/* Connect to weather server. */
	ZMQSocket *subscriber = [ctx socketWithType:ZMQ_SUB];
	[subscriber connectToEndpoint:kWeatherServerEndpoint];
	NSData *subData = [@"10001" dataUsingEncoding:NSUTF8StringEncoding];
	[subscriber setData:subData forOption:ZMQ_SUBSCRIBE];

	/* Initialize poll set. */
	zmq_pollitem_t items[2];
	[receiver getPollItem:&items[0] forEvents:ZMQ_POLLIN];
	[subscriber getPollItem:&items[1] forEvents:ZMQ_POLLIN];

	/* Process messages from both sockets. */
	for (;;) {
		NSAutoreleasePool *p = [[NSAutoreleasePool alloc] init];
		[ZMQContext pollWithItems:items count:2
				timeoutAfterUsec:ZMQPollTimeoutNever];
		[p drain];
	}

	/* NOT REACHED */
	[ctx closeSockets];
	[pool drain];  /* This finally releases the autoreleased context. */
	return EXIT_SUCCESS;
}

# Reading from multiple sockets in Perl
# This version uses AnyEvent to poll the sockets

use strict;
use warnings;
use v5.10;

use ZMQ::FFI;
use ZMQ::FFI::Constants qw(ZMQ_PULL ZMQ_SUB);

use AnyEvent;
use EV;

# Connect to the task ventilator
my $context = ZMQ::FFI->new();
my $receiver = $context->socket(ZMQ_PULL);
$receiver->connect('tcp://localhost:5557');

# Connect to weather server
my $subscriber = $context->socket(ZMQ_SUB);
$subscriber->connect('tcp://localhost:5556');
$subscriber->subscribe('10001');

my $pull_poller = AE::io $receiver->get_fd, 0, sub {
    while ($receiver->has_pollin) {
        my $msg = $receiver->recv();
        # Process task
    }
};

my $sub_poller = AE::io $subscriber->get_fd, 0, sub {
    while ($subscriber->has_pollin) {
        my $msg = $subscriber->recv();
        # Process weather update
    }
};

EV::run;

<?php
/*
 *  Reading from multiple sockets
 *  This version uses zmq_poll()
 * @author Ian Barber <ian(dot)barber(at)gmail(dot)com>
 */

$context = new ZMQContext();

//  Connect to task ventilator
$receiver = new ZMQSocket($context, ZMQ::SOCKET_PULL);
$receiver->connect("tcp://localhost:5557");

//  Connect to weather server
$subscriber = new ZMQSocket($context, ZMQ::SOCKET_SUB);
$subscriber->connect("tcp://localhost:5556");
$subscriber->setSockOpt(ZMQ::SOCKOPT_SUBSCRIBE, "10001");

//  Initialize poll set
$poll = new ZMQPoll();
$poll->add($receiver, ZMQ::POLL_IN);
$poll->add($subscriber, ZMQ::POLL_IN);

$readable = $writeable = array();

//  Process messages from both sockets
while (true) {
    $events = $poll->poll($readable, $writeable);
    if ($events > 0) {
        foreach ($readable as $socket) {
            if ($socket === $receiver) {
                $message = $socket->recv();
                // Process task
            } elseif ($socket === $subscriber) {
                $mesage = $socket->recv();
                // Process weather update
            }
        }
    }
}

//  We never get here

# encoding: utf-8
#
#   Reading from multiple sockets
#   This version uses zmq.Poller()
#
#   Author: Jeremy Avnet (brainsik) <spork(dash)zmq(at)theory(dot)org>
#

import zmq

# Prepare our context and sockets
context = zmq.Context()

# Connect to task ventilator
receiver = context.socket(zmq.PULL)
receiver.connect("tcp://localhost:5557")

# Connect to weather server
subscriber = context.socket(zmq.SUB)
subscriber.connect("tcp://localhost:5556")
subscriber.setsockopt(zmq.SUBSCRIBE, b"10001")

# Initialize poll set
poller = zmq.Poller()
poller.register(receiver, zmq.POLLIN)
poller.register(subscriber, zmq.POLLIN)

# Process messages from both sockets
while True:
    try:
        socks = dict(poller.poll())
    except KeyboardInterrupt:
        break

    if receiver in socks:
        message = receiver.recv()
        # process task

    if subscriber in socks:
        message = subscriber.recv()
        # process weather update

#!/usr/bin/env ruby

# author: Oleg Sidorov <4pcbr> i4pcbr@gmail.com
# this code is licenced under the MIT/X11 licence.
#
# Reading from multiple sockets
# This version uses a polling

require 'rubygems'
require 'ffi-rzmq'

context = ZMQ::Context.new

# Connect to task ventilator
receiver = context.socket(ZMQ::PULL)
receiver.connect('tcp://localhost:5557')

# Connect to weather server
subscriber = context.socket(ZMQ::SUB)
subscriber.connect('tcp://localhost:5556')
subscriber.setsockopt(ZMQ::SUBSCRIBE, '10001')

# Initialize a poll set
poller = ZMQ::Poller.new
poller.register(receiver, ZMQ::POLLIN)
poller.register(subscriber, ZMQ::POLLIN)

while true
  poller.poll(:blocking)
  poller.readables.each do |socket|
    if socket === receiver
      socket.recv_string(message = '')
      # process task
       puts "task: #{message}"
      
    elsif socket === subscriber
      socket.recv_string(message = '')
      # process weather update
      puts "weather: #{message}"
      
    end
  end
end

fn main() {
    let context = zmq::Context::new();

    let receiver = context.socket(zmq::PULL).unwrap();
    assert!(receiver.connect("tcp://localhost:5557").is_ok());

    let subscriber = context.socket(zmq::SUB).unwrap();
    assert!(subscriber.connect("tcp://localhost:5556").is_ok());
    assert!(subscriber.set_subscribe(b"10001").is_ok());

    let items = &mut [
        receiver.as_poll_item(zmq::POLLIN),
        subscriber.as_poll_item(zmq::POLLIN),
    ];

    loop {
        zmq::poll(items, -1).unwrap();
        if items[0].is_readable() {
            let _ = receiver.recv_msg(0);
        }
        if items[1].is_readable() {
            let _ = subscriber.recv_msg(0);
        }
    }
}

/*
 *  Reading from multiple sockets in Scala
 *  This version uses ZMQ.Poller
 *
 * @author Giovanni Ruggiero
 * @email giovanni.ruggiero@gmail.com
 */

import org.zeromq.ZMQ

object mspoller {
  def main(args : Array[String]) {

		val context = ZMQ.context(1)

		// Connect to task ventilator
		val receiver = context.socket(ZMQ.PULL)
		receiver.connect("tcp://localhost:5557")

		//  Connect to weather server
		val subscriber = context.socket(ZMQ.SUB)
		subscriber.connect("tcp://localhost:5556")
		subscriber.subscribe("10001 ".getBytes())

		//  Initialize poll set
		val items = context.poller(2)
		items.register(receiver, 0)
		items.register(subscriber, 0)

		//  Process messages from both sockets
		while (true) {
			items.poll()
			if (items.pollin(0)) {
				val message0 = receiver.recv(0)
				//  Process task
			}
			if (items.pollin(1)) {
				val message1 = subscriber.recv(0)
				//  Process weather update
			}
		}
	}
}

#
# Reading from multiple sockets
# This version uses a simple recv loop
#

package require zmq

# Prepare our context and sockets
zmq context context

# Connect to task ventilator
zmq socket receiver context PULL
receiver connect "tcp://localhost:5557"

# Connect to weather server
zmq socket subscriber context SUB
subscriber connect "tcp://*:5556"
subscriber setsockopt SUBSCRIBE "10001"

# Socket to send messages to
zmq socket sender context PUSH
sender connect "tcp://localhost:5558"

# Initialise poll set
set poll_set [list [list receiver [list POLLIN]] [list subscriber [list POLLIN]]]

# Process message from both sockets
while {1} {
    set rpoll_set [zmq poll $poll_set -1]
    foreach rpoll $rpoll_set {
	switch [lindex $rpoll 0] {
	    receiver {
		if {"POLLIN" in [lindex $rpoll 1]} {
		    set string [receiver recv]
		    # Do the work
		    puts "Process task: $string"
		    after $string
		    # Send result to sink
		    sender send "$string"
		}
	    }
	    subscriber {
		if {"POLLIN" in [lindex $rpoll 1]} {
		    set string [subscriber recv]
		    puts "Weather update: $string"
		}
	    }
	}
    }
    # No activity, sleep for 1 msec
    after 1
}

# We never get here but clean up anyhow
sender close
receiver close
subscriber close
context term

//  Hello World client
//  Connects REQ socket to tcp://localhost:5559
//  Sends "Hello" to server, expects "World" back

#include "zhelpers.h"

int main (void) 
{
    void *context = zmq_ctx_new ();

    //  Socket to talk to server
    void *requester = zmq_socket (context, ZMQ_REQ);
    zmq_connect (requester, "tcp://localhost:5559");

    int request_nbr;
    for (request_nbr = 0; request_nbr != 10; request_nbr++) {
        s_send (requester, "Hello");
        char *string = s_recv (requester);
        printf ("Received reply %d [%s]\n", request_nbr, string);
        free (string);
    }
    zmq_close (requester);
    zmq_ctx_destroy (context);
    return 0;
}

//   Request-reply client in C++
//   Connects REQ socket to tcp://localhost:5559
//   Sends "Hello" to server, expects "World" back
//

#include "zhelpers.hpp"
 
int main (int argc, char *argv[])
{
    zmq::context_t context(1);

	zmq::socket_t requester(context, ZMQ_REQ);
	requester.connect("tcp://localhost:5559");
 
	for( int request = 0 ; request < 10 ; request++) {
		
		s_send (requester, std::string("Hello"));
        std::string string = s_recv (requester);
		
		std::cout << "Received reply " << request 
				<< " [" << string << "]" << std::endl;
	}
}

;;; -*- Mode:Lisp; Syntax:ANSI-Common-Lisp; -*-
;;;
;;;  Hello World client in Common Lisp
;;;  Connects REQ socket to tcp://localhost:5555
;;;  Sends "Hello" to server, expects "World" back
;;;
;;; Kamil Shakirov <kamils80@gmail.com>
;;;

(defpackage #:zguide.rrclient
  (:nicknames #:rrclient)
  (:use #:cl #:zhelpers)
  (:export #:main))

(in-package :zguide.rrclient)

(defun main ()
  (zmq:with-context (context 1)
    ;; Socket to talk to server
    (zmq:with-socket (requester context zmq:req)
      (zmq:connect requester "tcp://localhost:5559")

      (dotimes (request-nbr 10)
        (let ((request (make-instance 'zmq:msg :data "Hello")))
          (zmq:send requester request))

        (let ((response (make-instance 'zmq:msg)))
          (zmq:recv requester response)
          (message "Received reply ~D: [~A]~%"
                   request-nbr (zmq:msg-data-as-string response))))))

  (cleanup))

#! /usr/bin/env escript
%%
%% Hello World client
%% Connects REQ socket to tcp://localhost:5559
%% Sends "Hello" to server, expects "World" back
%%

main(_) ->
    {ok, Context} = erlzmq:context(),

    %% Socket to talk to server
    {ok, Requester} = erlzmq:socket(Context, req),
    ok = erlzmq:connect(Requester, "tcp://*:5559"),

    lists:foreach(
      fun(Num) ->
              erlzmq:send(Requester, <<"Hello">>),
              {ok, Reply} = erlzmq:recv(Requester),
              io:format("Received reply ~b [~s]~n", [Num, Reply])
      end, lists:seq(1, 10)),

    ok = erlzmq:close(Requester),
    ok = erlzmq:term(Context).

defmodule Rrclient do
  @moduledoc """
  Generated by erl2ex (http://github.com/dazuma/erl2ex)
  From Erlang source: (Unknown source file)
  At: 2019-12-20 13:57:31

  """

  def main() do
    {:ok, context} = :erlzmq.context()
    {:ok, requester} = :erlzmq.socket(context, :req)
    #:ok = :erlzmq.connect(requester, 'tcp://*:5559')
    :ok = :erlzmq.connect(requester, 'tcp://localhost:5559')
    :lists.foreach(fn num ->
      :erlzmq.send(requester, "Hello")
      {:ok, reply} = :erlzmq.recv(requester)
      :io.format('Received reply ~b [~s]~n', [num, reply])
    end, :lists.seq(1, 10))
    :ok = :erlzmq.close(requester)
    :ok = :erlzmq.term(context)
  end

end

Rrclient.main()

// Hello World client
// Connects REQ socket to tcp://localhost:5559
// Sends "Hello" to server, expects "World" back
//
// Author:  Brendan Mc.
// Requires: http://github.com/alecthomas/gozmq

package main

import (
	"fmt"
	zmq "github.com/alecthomas/gozmq"
)

func main() {
	context, _ := zmq.NewContext()
	defer context.Close()

	// Socket to talk to clients
	requester, _ := context.NewSocket(zmq.REQ)
	defer requester.Close()
	requester.Connect("tcp://localhost:5559")

	for i := 0; i < 10; i++ {
		requester.Send([]byte("Hello"), 0)
		reply, _ := requester.Recv(0)
		fmt.Printf("Received reply %d [%s]\n", i, reply)
	}
}

{-# LANGUAGE OverloadedStrings #-}
-- |
-- Request/Reply Hello World with broker (p.50) 
-- Binds REQ socket to tcp://localhost:5559
-- Sends "Hello" to server, expects "World" back
-- 
-- Use with `rrbroker.hs` and `rrworker.hs`
-- You need to start the broker first !

module Main where

import System.ZMQ4.Monadic 
import Control.Monad (forM_)
import Data.ByteString.Char8 (unpack)
import Text.Printf

main :: IO ()
main = 
    runZMQ $ do
        requester <- socket Req
        connect requester "tcp://localhost:5559"
        forM_ [1..10] $ \i -> do
            send requester [] "Hello"  
            msg <- receive requester
            liftIO $ printf "Received reply %d %s\n" (i ::Int) (unpack msg)

package ;

import neko.Lib;
import haxe.io.Bytes;
import org.zeromq.ZMQ;
import org.zeromq.ZMQContext;
import org.zeromq.ZMQSocket;

/**
 * Hello World Client
 * Connects REQ socket to tcp://localhost:5559
 * Sends "Hello" to server, expects "World" back
 * 
 * See: http://zguide.zeromq.org/page:all#A-Request-Reply-Broker
 * 
 * Use with RrServer and RrBroker
 */
class RrClient 
{

    public static function main() {
        var context:ZMQContext = ZMQContext.instance();
        
		Lib.println("** RrClient (see: http://zguide.zeromq.org/page:all#A-Request-Reply-Broker)");

		var requester:ZMQSocket = context.socket(ZMQ_REQ);
		requester.connect ("tcp://localhost:5559");
		
        Lib.println ("Launch and connect client.");
        
		// Do 10 requests, waiting each time for a response
		for (i in 0...10) {
			var requestString = "Hello ";
			// Send the message
			requester.sendMsg(Bytes.ofString(requestString));
			
			// Wait for the reply
			var msg:Bytes = requester.recvMsg();
			
			Lib.println("Received reply " + i + ": [" + msg.toString() + "]");
			
		}
		
		// Shut down socket and context
		requester.close();
		context.term();
    }
}

package guide;

import org.zeromq.SocketType;
import org.zeromq.ZMQ;
import org.zeromq.ZMQ.Socket;
import org.zeromq.ZContext;

/**
* Hello World client
* Connects REQ socket to tcp://localhost:5559
* Sends "Hello" to server, expects "World" back
*/
public class rrclient
{

    public static void main(String[] args)
    {
        try (ZContext context = new ZContext()) {
            //  Socket to talk to server
            Socket requester = context.createSocket(SocketType.REQ);
            requester.connect("tcp://localhost:5559");

            System.out.println("launch and connect client.");

            for (int request_nbr = 0; request_nbr < 10; request_nbr++) {
                requester.send("Hello", 0);
                String reply = requester.recvStr(0);
                System.out.println(
                    "Received reply " + request_nbr + " [" + reply + "]"
                );
            }
        }
    }
}

--
--  Hello World client
--  Connects REQ socket to tcp://localhost:5559
--  Sends "Hello" to server, expects "World" back
--
--  Author: Robert G. Jakabosky <bobby@sharedrealm.com>
--
require"zmq"
require"zhelpers"

local context = zmq.init(1)

--  Socket to talk to server
local requester = context:socket(zmq.REQ)
requester:connect("tcp://localhost:5559")

for n=0,9 do
    requester:send("Hello")
    local msg = requester:recv()
    printf ("Received reply %d [%s]\n", n, msg)
end
requester:close()
context:term()

// Hello World client in Node.js
// Connects REQ socket to tcp://localhost:5559
// Sends "Hello" to server, expects "World" back

var zmq       = require('zeromq')
  , requester = zmq.socket('req');

requester.connect('tcp://localhost:5559');
var replyNbr = 0;
requester.on('message', function(msg) {
  console.log('got reply', replyNbr, msg.toString());
  replyNbr += 1;
});

for (var i = 0; i < 10; ++i) {
  requester.send("Hello");
}

# Hello world client in Perl
# Connects REQ socket to tcp://localhost:5559
# Sends "Hello" to server, expects "World" back

use strict;
use warnings;
use v5.10;

use ZMQ::FFI;
use ZMQ::FFI::Constants qw(ZMQ_REQ);

my $context = ZMQ::FFI->new();

# Socket to talk to server
my $requester = $context->socket(ZMQ_REQ);
$requester->connect('tcp://localhost:5559');

for my $request_nbr (1..10) {
    $requester->send("Hello");
    my $string = $requester->recv();
    say "Received reply $request_nbr [$string]";
}

<?php
/*
 * Hello World client
 * Connects REQ socket to tcp://localhost:5559
 * Sends "Hello" to server, expects "World" back
 * @author Ian Barber <ian(dot)barber(at)gmail(dot)com>
 */

$context = new ZMQContext();

//  Socket to talk to server
$requester = new ZMQSocket($context, ZMQ::SOCKET_REQ);
$requester->connect("tcp://localhost:5559");

for ($request_nbr = 0; $request_nbr < 10; $request_nbr++) {
    $requester->send("Hello");
    $string = $requester->recv();
    printf ("Received reply %d [%s]%s", $request_nbr, $string, PHP_EOL);
}

#
#   Request-reply client in Python
#   Connects REQ socket to tcp://localhost:5559
#   Sends "Hello" to server, expects "World" back
#
import zmq

#  Prepare our context and sockets
context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect("tcp://localhost:5559")

#  Do 10 requests, waiting each time for a response
for request in range(1, 11):
    socket.send(b"Hello")
    message = socket.recv()
    print(f"Received reply {request} [{message}]")

#lang racket
#|
#   Request-reply client in Racket
#   Connects REQ socket to tcp://localhost:5559
#   Sends "Hello" to server, expects "World" back
|#
(require net/zmq)

;  Prepare our context and sockets
(define ctxt (context 1))
(define sock (socket ctxt 'REQ))

(socket-connect! sock "tcp://localhost:5559")

;  Do 10 requests, waiting each time for a response
(for ([request (in-range 10)])
  (printf "Sending request ~a...\n" request)
  (socket-send! sock #"Hello")
  
  ;  Get the reply.
  (define message (socket-recv! sock))
  (printf "Received reply ~a [~a]\n" request message))

(context-close! ctxt)

#!/usr/bin/env ruby

# author: Oleg Sidorov <4pcbr> i4pcbr@gmail.com
# this code is licenced under the MIT/X11 licence.

require 'rubygems'
require 'ffi-rzmq'

context = ZMQ::Context.new
socket = context.socket(ZMQ::REQ)
socket.connect('tcp://localhost:5559')

10.times do |request|
  string = "Hello #{request}"
  socket.send_string(string)
  puts "Sending string [#{string}]"
  socket.recv_string(message = '')
  puts "Received reply #{request}[#{message}]"
end

fn main() {
    let context = zmq::Context::new();

    let requester = context.socket(zmq::REQ).unwrap();
    assert!(requester.connect("tcp://localhost:5559").is_ok());

    for request_nbr in 0..10 {
        requester.send("Hello", 0).unwrap();
        let string = requester.recv_string(0).unwrap().unwrap();
        println!("Received reply {} {}", request_nbr, string);
    }
}

/*
 *  Hello World client in Scala
 *  Connects REQ socket to tcp://localhost:5555
 *  Sends "Hello" to server, expects "World" back
 *
 * @author Giovanni Ruggiero
 * @email giovanni.ruggiero@gmail.com
*/

import org.zeromq.ZMQ
import org.zeromq.ZMQ.{Context,Socket}

object rrclient{
  def main(args : Array[String]) {
    //  Prepare our context and socket
    val context = ZMQ.context(1)
    val requester = context.socket(ZMQ.REQ)

    requester.connect ("tcp://localhost:5559")

		for (request_nbr <- 1 to 10)  {
			val request = "Hello ".getBytes()
      request(request.length-1)=0 //Sets the last byte to 0
      // Send the message
      println("Sending request " + request_nbr + "...") + request.toString
      requester.send(request, 0)

      //  Get the reply.
      val reply = requester.recv(0)
      //  When displaying reply as a String, omit the last byte because
      //  our "Hello World" server has sent us a 0-terminated string:
      println("Received reply " + request_nbr + ": [" + new String(reply,0,reply.length-1) + "]")
    }
  }
}

#
# Hello World client
# Connects REQ socket to tcp://localhost:5559
# Sends "Hello" to server, expects "World" back
#

package require zmq

zmq context context

# Socket to talk to server
zmq socket requester context REQ
requester connect "tcp://localhost:5559"

for {set request_nbr 0} {$request_nbr < 10} { incr request_nbr} {
    requester send "Hello"
    set string [requester recv]
    puts "Received reply $request_nbr \[$string\]"
}

requester close
context term

(**
 * Hello World client
 * Connects REQ socket to tcp://localhost:5559
 * Sends "Hello" to server, expects "World" back
 *)
open Zmq
open Helpers

let () =
    with_context @@ fun ctx ->

    (* Socket to talk to server *)
    with_socket ctx Socket.req @@ fun requester ->
    Socket.connect requester "tcp://localhost:5559";

    for requestNum = 0 to 9 do
        Socket.send requester "Hello";
        let s = Socket.recv requester in
        printfn "Received reply %d [%S]" requestNum s;
    done

//  Hello World worker
//  Connects REP socket to tcp://localhost:5560
//  Expects "Hello" from client, replies with "World"

#include "zhelpers.h"
#include <unistd.h>

int main (void) 
{
    void *context = zmq_ctx_new ();

    //  Socket to talk to clients
    void *responder = zmq_socket (context, ZMQ_REP);
    zmq_connect (responder, "tcp://localhost:5560");

    while (1) {
        //  Wait for next request from client
        char *string = s_recv (responder);
        printf ("Received request: [%s]\n", string);
        free (string);

        //  Do some 'work'
        sleep (1);

        //  Send reply back to client
        s_send (responder, "World");
    }
    //  We never get here, but clean up anyhow
    zmq_close (responder);
    zmq_ctx_destroy (context);
    return 0;
}

//
//   Request-reply service in C++
//   Connects REP socket to tcp://localhost:5560
//   Expects "Hello" from client, replies with "World"
//


#include "zhelpers.hpp"
 
int main (int argc, char *argv[])
{
    zmq::context_t context(1);

	zmq::socket_t responder(context, ZMQ_REP);
	responder.connect("tcp://localhost:5560");
 
	while(1)
	{
		//  Wait for next request from client
		std::string string = s_recv (responder);
		
		std::cout << "Received request: " << string << std::endl;
		
		// Do some 'work'
        sleep (1);
        
        //  Send reply back to client
		s_send (responder, std::string("World"));
		
	}
}

;;; -*- Mode:Lisp; Syntax:ANSI-Common-Lisp; -*-
;;;
;;;  Hello World server in Common Lisp
;;;  Binds REP socket to tcp://*:5555
;;;  Expects "Hello" from client, replies with "World"
;;;
;;; Kamil Shakirov <kamils80@gmail.com>
;;;

(defpackage #:zguide.rrserver
  (:nicknames #:rrserver)
  (:use #:cl #:zhelpers)
  (:export #:main))

(in-package :zguide.rrserver)

(defun main ()
  (zmq:with-context (context 1)
    ;; Socket to talk to clients
    (zmq:with-socket (responder context zmq:rep)
      (zmq:connect responder "tcp://localhost:5560")

      (loop
        (let ((request (make-instance 'zmq:msg)))
          ;; Wait for next request from client
          (zmq:recv responder request)
          (message "Received request: [~A]~%"
                   (zmq:msg-data-as-string request))

          ;; Do some 'work'
          (sleep 1)

          ;; Send reply back to client
          (let ((reply (make-instance 'zmq:msg :data "World")))
            (zmq:send responder reply))))))

  (cleanup))

#! /usr/bin/env escript
%%
%% Hello World server
%% Connects REP socket to tcp://*:5560
%% Expects "Hello" from client, replies with "World"
%%

main(_) ->
    {ok, Context} = erlzmq:context(),

    %% Socket to talk to clients
    {ok, Responder} = erlzmq:socket(Context, rep),
    ok = erlzmq:connect(Responder, "tcp://*:5560"),

    loop(Responder),

    %% We never get here but clean up anyhow
    ok = erlzmq:close(Responder),
    ok = erlzmq:term(Context).

loop(Socket) ->
    %% Wait for next request from client
    {ok, Req} = erlzmq:recv(Socket),
    io:format("Received request: [~s]~n", [Req]),

    %% Do some 'work'
    timer:sleep(1000),

    %% Send reply back to client
    ok = erlzmq:send(Socket, <<"World">>),

    loop(Socket).

defmodule Rrworker do
  @moduledoc """
  Generated by erl2ex (http://github.com/dazuma/erl2ex)
  From Erlang source: (Unknown source file)
  At: 2019-12-20 13:57:32

  """

  def main() do
    {:ok, context} = :erlzmq.context()
    {:ok, responder} = :erlzmq.socket(context, :rep)
    #:ok = :erlzmq.connect(responder, 'tcp://*:5560')
    :ok = :erlzmq.connect(responder, 'tcp://localhost:5560')
    loop(responder)
    :ok = :erlzmq.close(responder)
    :ok = :erlzmq.term(context)
  end


  def loop(socket) do
    {:ok, req} = :erlzmq.recv(socket)
    :io.format('Received request: [~s]~n', [req])
    :timer.sleep(1000)
    :ok = :erlzmq.send(socket, "World")
    loop(socket)
  end

end

Rrworker.main()

// Hello World server
// Connects REP socket to tcp://*:5560
// Expects "Hello" from client, replies with "World"
//
// Author:  Brendan Mc.
// Requires: http://github.com/alecthomas/gozmq

package main

import (
	"fmt"
	zmq "github.com/alecthomas/gozmq"
	"time"
)

func main() {
	context, _ := zmq.NewContext()
	defer context.Close()

	// Socket to talk to clients
	responder, _ := context.NewSocket(zmq.REP)
	defer responder.Close()
	responder.Connect("tcp://localhost:5560")

	for {
		//  Wait for next request from client
		request, _ := responder.Recv(0)
		fmt.Printf("Received request: [%s]\n", request)

		// Do some 'work'
		time.Sleep(1 * time.Second)

		// Send reply back to client
		responder.Send([]byte("World"), 0)
	}
}

{-# LANGUAGE OverloadedStrings #-}
-- |
-- A worker that simulates some work with a timeout
-- And send back "World"
-- Connect REP socket to tcp://*:5560
-- Expects "Hello" from client, replies with "World"
-- 

module Main where

import System.ZMQ4.Monadic
import Control.Monad (forever)
import Data.ByteString.Char8 (unpack)
import Control.Concurrent (threadDelay)
import Text.Printf

main :: IO ()
main = 
    runZMQ $ do
        responder <- socket Rep
        connect responder "tcp://localhost:5560"
  
        forever $ do
            receive responder >>= liftIO . printf "Received request: [%s]\n" . unpack
            -- Simulate doing some 'work' for 1 second
            liftIO $ threadDelay (1 * 1000 * 1000)
            send responder [] "World"       
        
        



    

package ;

import haxe.io.Bytes;
import haxe.Stack;
import neko.Lib;
import neko.Sys;
import org.zeromq.ZMQ;
import org.zeromq.ZMQContext;
import org.zeromq.ZMQException;
import org.zeromq.ZMQSocket;

/**
 * Hello World server in Haxe
 * Binds REP to tcp://*:5560
 * Expects "Hello" from client, replies with "World"
 * Use with RrClient.hx and RrBroker.hx
 * 
 */
class RrServer 
{

	public static function main() {
		
		var context:ZMQContext = ZMQContext.instance();

		Lib.println("** RrServer (see: http://zguide.zeromq.org/page:all#A-Request-Reply-Broker)");

        // Socket to talk to clients
		var responder:ZMQSocket = context.socket(ZMQ_REP);
		responder.connect("tcp://localhost:5560");
		
        Lib.println("Launch and connect server.");
        
        ZMQ.catchSignals();
        
        while (true) {
            
            try {
                // Wait for next request from client
                var request:Bytes = responder.recvMsg();
                
                trace ("Received request:" + request.toString());
                
                // Do some work
                Sys.sleep(1);
                
                // Send reply back to client
                responder.sendMsg(Bytes.ofString("World"));
            } catch (e:ZMQException) {
				if (ZMQ.isInterrupted()) {
					break;
				}
				// Handle other errors
				trace("ZMQException #:" + e.errNo + ", str:" + e.str());
				trace (Stack.toString(Stack.exceptionStack()));
			}

        }
		responder.close();
		context.term();
		
	}
	
}

package guide;

import org.zeromq.SocketType;
import org.zeromq.ZMQ;
import org.zeromq.ZMQ.Socket;
import org.zeromq.ZContext;

//  Hello World worker
//  Connects REP socket to tcp://*:5560
//  Expects "Hello" from client, replies with "World"
public class rrworker
{
    public static void main(String[] args) throws Exception
    {
        try (ZContext context = new ZContext()) {
            //  Socket to talk to server
            Socket responder = context.createSocket(SocketType.REP);
            responder.connect("tcp://localhost:5560");

            while (!Thread.currentThread().isInterrupted()) {
                //  Wait for next request from client
                String string = responder.recvStr(0);
                System.out.printf("Received request: [%s]\n", string);

                //  Do some 'work'
                Thread.sleep(1000);

                //  Send reply back to client
                responder.send("World");
            }
        }
    }
}

--
--  Hello World server
--  Connects REP socket to tcp://*:5560
--  Expects "Hello" from client, replies with "World"
--
--  Author: Robert G. Jakabosky <bobby@sharedrealm.com>
--
require"zmq"
require"zhelpers"

local context = zmq.init(1)

--  Socket to talk to clients
local responder = context:socket(zmq.REP)
responder:connect("tcp://localhost:5560")

while true do
    --  Wait for next request from client
    local msg = responder:recv()
    printf ("Received request: [%s]\n", msg)

    --  Do some 'work'
    s_sleep (1000)

    --  Send reply back to client
    responder:send("World")
end
--  We never get here but clean up anyhow
responder:close()
context:term()

// Hello World server in Node.js
// Connects REP socket to tcp://*:5560
// Expects "Hello" from client, replies with "World"

var zmq = require('zeromq')
  , responder = zmq.socket('rep');

responder.connect('tcp://localhost:5560');
responder.on('message', function(msg) {
  console.log('received request:', msg.toString());
  setTimeout(function() {
    responder.send("World");
  }, 1000);
});

# Hello world worker in Perl
# Connects REP socket to tcp://localhost:5560
# Expects "Hello from client, replies with "World"

use strict;
use warnings;
use v5.10;

use ZMQ::FFI;
use ZMQ::FFI::Constants qw(ZMQ_REP);

my $context = ZMQ::FFI->new();

# Socket to talk to clients
my $responder = $context->socket(ZMQ_REP);
$responder->connect('tcp://localhost:5560');

while (1) {
    # Wait for next request from client
    my $string = $responder->recv();
    say "Received request: [$string]";

    # Do some 'work'
    sleep 1;

    # Send reply back to client
    $responder->send("World");
}

<?php
/*
 * Hello World server
 * Connects REP socket to tcp://*:5560
 * Expects "Hello" from client, replies with "World"
 * @author Ian Barber <ian(dot)barber(at)gmail(dot)com>
 */

$context = new ZMQContext();

//  Socket to talk to clients
$responder = new ZMQSocket($context, ZMQ::SOCKET_REP);
$responder->connect("tcp://localhost:5560");

while (true) {
    //  Wait for next request from client
    $string = $responder->recv();
    printf ("Received request: [%s]%s", $string, PHP_EOL);

    // Do some 'work'
    sleep(1);

    //  Send reply back to client
    $responder->send("World");
}

#
#   Request-reply service in Python
#   Connects REP socket to tcp://localhost:5560
#   Expects "Hello" from client, replies with "World"
#
import zmq

context = zmq.Context()
socket = context.socket(zmq.REP)
socket.connect("tcp://localhost:5560")

while True:
    message = socket.recv()
    print(f"Received request: {message}")
    socket.send(b"World")

#lang racket
#|
   Request-reply server in Racket
   Binds REP socket to tcp://*:5560
   Expects "Hello" from client, replies with "World"
|#
(require net/zmq)

(define ctxt (context 1))
(define sock (socket ctxt 'REP))
(socket-bind! sock "tcp://*:5560")

(let loop ()
  (define message (socket-recv! sock))
  (printf "Received request: ~a\n" message)
  (sleep 1)
  (socket-send! sock #"World")
  (loop))

(context-close! ctxt)

#!/usr/bin/env ruby

# author: Oleg Sidorov <4pcbr> i4pcbr@gmail.com
# this code is licenced under the MIT/X11 licence.

require 'rubygems'
require 'ffi-rzmq'

context = ZMQ::Context.new
socket = context.socket(ZMQ::REP)
socket.connect('tcp://localhost:5560')

loop do
  socket.recv_string(message = '')
  puts "Received request: #{message}"
  socket.send_string('World')
end

use std::{thread, time};

fn main() {
    let context = zmq::Context::new();

    let responder = context.socket(zmq::REP).unwrap();
    assert!(responder.connect("tcp://localhost:5560").is_ok());

    loop {
        let string = responder.recv_string(0).unwrap().unwrap();
        println!("Received request: {}", string);

        thread::sleep(time::Duration::from_secs(1));

        responder.send("World", 0).unwrap();
    }
}

/*
 *  Hello World server in Scala
 *  Binds REP socket to tcp://localhost:5560
 *  Expects "Hello" from client, replies with "World"
 *
 *  @author Giovanni Ruggiero
 *  @email giovanni.ruggiero@gmail.com
 *
*/

import org.zeromq.ZMQ
import org.zeromq.ZMQ.{Context,Socket}

object rrserver {
  def main(args : Array[String]) {
    //  Prepare our context and socket
    val context = ZMQ.context(1)
    val receiver = context.socket(ZMQ.REP)
		receiver.connect("tcp://localhost:5560")

    while (true) {
      //  Wait for next request from client
      //  We will wait for a 0-terminated string (C string) from the client,
      //  so that this server also works with The Guide's C and C++ "Hello World" clients
      val request = receiver.recv (0)
      //  In order to display the 0-terminated string as a String,
      //  we omit the last byte from request
      println ("Received request: [" + new String(request,0,request.length-1)  //  Creates a String from request, minus the last byte
							 + "]")

      //  Do some 'work'
      try {
        Thread.sleep (1000)
      } catch  {
        case e: InterruptedException => e.printStackTrace()
      }

      //  Send reply back to client
      //  We will send a 0-terminated string (C string) back to the client,
      //  so that this server also works with The Guide's C and C++ "Hello World" clients
      val reply = "World ".getBytes
      reply(reply.length-1)=0 //Sets the last byte of the reply to 0
      receiver.send(reply, 0)
    }
  }
}

#
#  Hello World server
#  Connects REP socket to tcp://*:5560
#  Expects "Hello" from client, replies with "World"
#

package require zmq

zmq context context

# Socket to talk to clients
zmq socket responder context REP
responder connect "tcp://localhost:5560"

while {1} {
    # Wait for next request from client
    set string [responder recv]
    puts "Received request: \[$string\]"

    # Do some 'work'
    after 1000;

    # Send reply back to client
    responder send "World"
}

# We never get here but clean up anyhow
responder close
context term

(**
 * Hello World worker
 * Connects REP socket to tcp://*:5560
 * Expects "Hello" from client, replies with "World"
 *)
open Zmq
open Helpers

let () =
    with_context @@ fun ctx ->

    (* Socket to talk to clients *)
    with_socket ctx Socket.rep @@ fun responder ->
    Socket.connect responder "tcp://localhost:5560";

    while true do
        (* Wait for next request from client *)
        let s = Socket.recv responder in
        printfn "Received request: [%S]" s;

        (* Do some 'work' *)
        sleep_ms 1;

        (* Send reply back to client *)
        Socket.send responder "World";
    done

//  Simple request-reply broker

#include "zhelpers.h"

int main (void) 
{
    //  Prepare our context and sockets
    void *context = zmq_ctx_new ();
    void *frontend = zmq_socket (context, ZMQ_ROUTER);
    void *backend  = zmq_socket (context, ZMQ_DEALER);
    zmq_bind (frontend, "tcp://*:5559");
    zmq_bind (backend,  "tcp://*:5560");

    //  Initialize poll set
    zmq_pollitem_t items [] = {
        { frontend, 0, ZMQ_POLLIN, 0 },
        { backend,  0, ZMQ_POLLIN, 0 }
    };
    //  Switch messages between sockets
    while (1) {
        zmq_msg_t message;
        zmq_poll (items, 2, -1);
        if (items [0].revents & ZMQ_POLLIN) {
            while (1) {
                //  Process all parts of the message
                zmq_msg_init (&message);
                zmq_msg_recv (&message, frontend, 0);
                int more = zmq_msg_more (&message);
                zmq_msg_send (&message, backend, more? ZMQ_SNDMORE: 0);
                zmq_msg_close (&message);
                if (!more)
                    break;      //  Last message part
            }
        }
        if (items [1].revents & ZMQ_POLLIN) {
            while (1) {
                //  Process all parts of the message
                zmq_msg_init (&message);
                zmq_msg_recv (&message, backend, 0);
                int more = zmq_msg_more (&message);
                zmq_msg_send (&message, frontend, more? ZMQ_SNDMORE: 0);
                zmq_msg_close (&message);
                if (!more)
                    break;      //  Last message part
            }
        }
    }
    //  We never get here, but clean up anyhow
    zmq_close (frontend);
    zmq_close (backend);
    zmq_ctx_destroy (context);
    return 0;
}

//
//  Simple request-reply broker in C++
//

#include "zhelpers.hpp"


int main (int argc, char *argv[])
{
    //  Prepare our context and sockets
    zmq::context_t context(1);
    zmq::socket_t frontend (context, ZMQ_ROUTER);
    zmq::socket_t backend (context, ZMQ_DEALER);

    frontend.bind("tcp://*:5559");
    backend.bind("tcp://*:5560");

    //  Initialize poll set
    zmq::pollitem_t items [] = {
        { frontend, 0, ZMQ_POLLIN, 0 },
        { backend, 0, ZMQ_POLLIN, 0 }
    };
    
    //  Switch messages between sockets
    while (1) {
        zmq::message_t message;
        int more;               //  Multipart detection

        zmq::poll (&items [0], 2, -1);
        
        if (items [0].revents & ZMQ_POLLIN) {
            while (1) {
                //  Process all parts of the message
                frontend.recv(&message);
                // frontend.recv(message, zmq::recv_flags::none); // new syntax
                size_t more_size = sizeof (more);
                frontend.getsockopt(ZMQ_RCVMORE, &more, &more_size);
                backend.send(message, more? ZMQ_SNDMORE: 0);
                // more = frontend.get(zmq::sockopt::rcvmore); // new syntax
                // backend.send(message, more? zmq::send_flags::sndmore : zmq::send_flags::none);
                
                if (!more)
                    break;      //  Last message part
            }
        }
        if (items [1].revents & ZMQ_POLLIN) {
            while (1) {
                //  Process all parts of the message
                backend.recv(&message);
                size_t more_size = sizeof (more);
                backend.getsockopt(ZMQ_RCVMORE, &more, &more_size);
                frontend.send(message, more? ZMQ_SNDMORE: 0);
                // more = backend.get(zmq::sockopt::rcvmore); // new syntax
                //frontend.send(message, more? zmq::send_flags::sndmore : zmq::send_flags::none);

                if (!more)
                    break;      //  Last message part
            }
        }
    }
    return 0;
}

;;; -*- Mode:Lisp; Syntax:ANSI-Common-Lisp; -*-
;;;
;;;  Simple request-reply broker in Common Lisp
;;;
;;; Kamil Shakirov <kamils80@gmail.com>
;;;

(defpackage #:zguide.rrbroker
  (:nicknames #:rrbroker)
  (:use #:cl #:zhelpers)
  (:export #:main))

(in-package :zguide.rrbroker)

(defun main ()
  ;; Prepare our context and sockets
  (zmq:with-context (context 1)
    (zmq:with-socket (frontend context zmq:router)
      (zmq:with-socket (backend context zmq:dealer)
        (zmq:bind frontend "tcp://*:5559")
        (zmq:bind backend  "tcp://*:5560")

        ;; Initialize poll set
        (zmq:with-polls ((items . ((frontend . zmq:pollin)
                                   (backend  . zmq:pollin))))
          ;; Switch messages between sockets
          (loop
            (let ((revents (zmq:poll items)))
              (when (= (first revents) zmq:pollin)
                (loop
                  ;; Process all parts of the message
                 (let ((message (make-instance 'zmq:msg)))
                   (zmq:recv frontend message)

                   (if (not (zerop (zmq:getsockopt frontend zmq:rcvmore)))
                       (zmq:send backend message zmq:sndmore)
                       (progn
                         (zmq:send backend message 0)
                         ;; Last message part
                         (return))))))

              (when (= (second revents) zmq:pollin)
                (loop
                  ;; Process all parts of the message
                 (let ((message (make-instance 'zmq:msg)))
                   (zmq:recv backend message)

                   (if (not (zerop (zmq:getsockopt backend zmq:rcvmore)))
                       (zmq:send frontend message zmq:sndmore)
                       (progn
                         (zmq:send frontend message 0)
                         ;; Last message part
                         (return))))))))))))

  (cleanup))

#! /usr/bin/env escript
%%
%% Simple request-reply broker
%%

main(_) ->
    %% Prepare our context and sockets
    {ok, Context} = erlzmq:context(),
    {ok, Frontend} = erlzmq:socket(Context, [router, {active, true}]),
    {ok, Backend} = erlzmq:socket(Context, [dealer, {active, true}]),
    ok = erlzmq:bind(Frontend, "tcp://*:5559"),
    ok = erlzmq:bind(Backend, "tcp://*:5560"),

    %% Switch messages between sockets
    loop(Frontend, Backend),

    %% We never get here but clean up anyhow
    ok = erlzmq:close(Frontend),
    ok = erlzmq:close(Backend),
    ok = erlzmq:term(Context).

loop(Frontend, Backend) ->
    receive
        {zmq, Frontend, Msg, Flags} ->
            case proplists:get_bool(rcvmore, Flags) of
                true ->
                    erlzmq:send(Backend, Msg, [sndmore]);
                false ->
                    erlzmq:send(Backend, Msg)
            end;
        {zmq, Backend, Msg, Flags} ->
            case proplists:get_bool(rcvmore, Flags) of
                true ->
                    erlzmq:send(Frontend, Msg, [sndmore]);
                false ->
                    erlzmq:send(Frontend, Msg)
            end
    end,
    loop(Frontend, Backend).

defmodule Rrbroker do
  @moduledoc """
  Generated by erl2ex (http://github.com/dazuma/erl2ex)
  From Erlang source: (Unknown source file)
  At: 2019-12-20 13:57:31

  """

  def main() do
    {:ok, context} = :erlzmq.context()
    {:ok, frontend} = :erlzmq.socket(context, [:router, {:active, true}])
    {:ok, backend} = :erlzmq.socket(context, [:dealer, {:active, true}])
    :ok = :erlzmq.bind(frontend, 'tcp://*:5559')
    :ok = :erlzmq.bind(backend, 'tcp://*:5560')
    loop(frontend, backend)
    :ok = :erlzmq.close(frontend)
    :ok = :erlzmq.close(backend)
    :ok = :erlzmq.term(context)
  end


  def loop(frontend, backend) do
    receive do
      {:zmq, ^frontend, msg, flags} ->
        case(:proplists.get_bool(:rcvmore, flags)) do
          true ->
            :erlzmq.send(backend, msg, [:sndmore])
          false ->
            :erlzmq.send(backend, msg)
        end
      {:zmq, ^backend, msg, flags} ->
        case(:proplists.get_bool(:rcvmore, flags)) do
          true ->
            :erlzmq.send(frontend, msg, [:sndmore])
          false ->
            :erlzmq.send(frontend, msg)
        end
    end
    loop(frontend, backend)
  end

end

Rrbroker.main()

// Simple request-reply broker
//
// Author:  Brendan Mc.
// Requires: http://github.com/alecthomas/gozmq

package main

import (
	zmq "github.com/alecthomas/gozmq"
)

func main() {
	context, _ := zmq.NewContext()
	defer context.Close()

	frontend, _ := context.NewSocket(zmq.ROUTER)
	backend, _ := context.NewSocket(zmq.DEALER)
	defer frontend.Close()
	defer backend.Close()
	frontend.Bind("tcp://*:5559")
	backend.Bind("tcp://*:5560")

	// Initialize poll set
	toPoll := zmq.PollItems{
		zmq.PollItem{Socket: frontend, Events: zmq.POLLIN},
		zmq.PollItem{Socket: backend, Events: zmq.POLLIN},
	}

	for {
		_, _ = zmq.Poll(toPoll, -1)

		switch {
		case toPoll[0].REvents&zmq.POLLIN != 0:
			parts, _ := frontend.RecvMultipart(0)
			backend.SendMultipart(parts, 0)

		case toPoll[1].REvents&zmq.POLLIN != 0:
			parts, _ := backend.RecvMultipart(0)
			frontend.SendMultipart(parts, 0)
		}
	}
}

-- |
-- Simple message queuing broker
--
-- Use it with `rrclient.hs` and `rrworker.hs`//
module Main where

import System.ZMQ4.Monadic
import Control.Monad (forever)
import qualified Data.List.NonEmpty as NE -- from semigroups

main :: IO ()
main = runZMQ $ do
  frontend <- socket Router
  bind frontend "tcp://*:5559"
  backend <- socket Dealer
  bind backend "tcp://*:5560"
  forever $ poll (-1) [ Sock frontend [In] (Just $ frontend >|> backend)
                      , Sock backend [In] (Just $ backend >|> frontend)
                      ]

(>|>) :: (Receiver r, Sender s) => Socket z r -> Socket z s -> [Event] -> ZMQ z ()
(>|>) rcv snd _ = receiveMulti rcv >>= sendMulti snd . NE.fromList

package ;
import haxe.io.Bytes;
import haxe.Stack;
import neko.Lib;
import org.zeromq.ZMQ;
import org.zeromq.ZMQContext;
import org.zeromq.ZMQPoller;
import org.zeromq.ZMQSocket;
import org.zeromq.ZMQException;

/**
 * Simple request-reply broker
 * 
 * Use with RrClient.hx and RrServer.hx
 */
class RrBroker 
{

    public static function main() {
        var context:ZMQContext = ZMQContext.instance();
        
		Lib.println("** RrBroker (see: http://zguide.zeromq.org/page:all#A-Request-Reply-Broker)");
        
        var frontend:ZMQSocket = context.socket(ZMQ_ROUTER);
        var backend:ZMQSocket = context.socket(ZMQ_DEALER);
        frontend.bind("tcp://*:5559");
        backend.bind("tcp://*:5560");
        
        Lib.println("Launch and connect broker.");
        
        // Initialise poll set
        var items:ZMQPoller = context.poller();
        items.registerSocket(frontend, ZMQ.ZMQ_POLLIN());
        items.registerSocket(backend, ZMQ.ZMQ_POLLIN());
        
        var more = false;
        var msgBytes:Bytes;
        
        ZMQ.catchSignals();
        
        while (true) {
            try {
                items.poll();
                if (items.pollin(1)) {
                    while (true) {
                        // receive message
                        msgBytes = frontend.recvMsg();
                        more = frontend.hasReceiveMore();
                        // broker it to backend
                        backend.sendMsg(msgBytes, { if (more) SNDMORE else null; } );
                        if (!more) break;
                    }
                }
                
                if (items.pollin(2)) {
                    while (true) {
                        // receive message
                        msgBytes = backend.recvMsg();
                        more = backend.hasReceiveMore();
                        // broker it to frontend
                        frontend.sendMsg(msgBytes, { if (more) SNDMORE else null; } );
                        if (!more) break;
                    }
                }
            } catch (e:ZMQException) {
				if (ZMQ.isInterrupted()) {
					break;
				}
				// Handle other errors
				trace("ZMQException #:" + e.errNo + ", str:" + e.str());
				trace (Stack.toString(Stack.exceptionStack()));
			}
        }
        frontend.close();
        backend.close();
        context.term();
    }
}

package guide;

import org.zeromq.SocketType;
import org.zeromq.ZMQ;
import org.zeromq.ZMQ.Poller;
import org.zeromq.ZMQ.Socket;
import org.zeromq.ZContext;

/**
* Simple request-reply broker
*
*/
public class rrbroker
{

    public static void main(String[] args)
    {
        //  Prepare our context and sockets
        try (ZContext context = new ZContext()) {
            Socket frontend = context.createSocket(SocketType.ROUTER);
            Socket backend = context.createSocket(SocketType.DEALER);
            frontend.bind("tcp://*:5559");
            backend.bind("tcp://*:5560");

            System.out.println("launch and connect broker.");

            //  Initialize poll set
            Poller items = context.createPoller(2);
            items.register(frontend, Poller.POLLIN);
            items.register(backend, Poller.POLLIN);

            boolean more = false;
            byte[] message;

            //  Switch messages between sockets
            while (!Thread.currentThread().isInterrupted()) {
                //  poll and memorize multipart detection
                items.poll();

                if (items.pollin(0)) {
                    while (true) {
                        // receive message
                        message = frontend.recv(0);
                        more = frontend.hasReceiveMore();

                        // Broker it
                        backend.send(message, more ? ZMQ.SNDMORE : 0);
                        if (!more) {
                            break;
                        }
                    }
                }

                if (items.pollin(1)) {
                    while (true) {
                        // receive message
                        message = backend.recv(0);
                        more = backend.hasReceiveMore();
                        // Broker it
                        frontend.send(message, more ? ZMQ.SNDMORE : 0);
                        if (!more) {
                            break;
                        }
                    }
                }
            }
        }
    }
}

--
--  Simple request-reply broker
--
--  Author: Robert G. Jakabosky <bobby@sharedrealm.com>
--
require"zmq"
require"zmq.poller"
require"zhelpers"

--  Prepare our context and sockets
local context = zmq.init(1)
local frontend = context:socket(zmq.ROUTER)
local backend  = context:socket(zmq.DEALER)
frontend:bind("tcp://*:5559")
backend:bind("tcp://*:5560")

--  Switch messages between sockets
local poller = zmq.poller(2)
poller:add(frontend, zmq.POLLIN, function()
    while true do
        --  Process all parts of the message
        local msg = frontend:recv()
        if (frontend:getopt(zmq.RCVMORE) == 1) then
            backend:send(msg, zmq.SNDMORE)
        else
            backend:send(msg, 0)
            break;      --  Last message part
        end
    end
end)
poller:add(backend, zmq.POLLIN, function()
    while true do
        --  Process all parts of the message
        local msg = backend:recv()
        if (backend:getopt(zmq.RCVMORE) == 1) then
            frontend:send(msg, zmq.SNDMORE)
        else
            frontend:send(msg, 0)
            break;      --  Last message part
        end
    end
end)

-- start poller's event loop
poller:start()

--  We never get here but clean up anyhow
frontend:close()
backend:close()
context:term()

// Simple request-reply broker in Node.js

var zmq      = require('zeromq')
  , frontend = zmq.socket('router')
  , backend  = zmq.socket('dealer');

frontend.bindSync('tcp://*:5559');
backend.bindSync('tcp://*:5560');

frontend.on('message', function() {
  // Note that separate message parts come as function arguments.
  var args = Array.apply(null, arguments);
  // Pass array of strings/buffers to send multipart messages.
  backend.send(args);
});

backend.on('message', function() {
  var args = Array.apply(null, arguments);
  frontend.send(args);
});

# Simple request-reply broker in Perl
# Uses AnyEvent to poll the sockets

use strict;
use warnings;
use v5.10;

use ZMQ::FFI;
use ZMQ::FFI::Constants qw(ZMQ_ROUTER ZMQ_DEALER);

use AnyEvent;
use EV;

# Prepare our context and sockets
my $context  = ZMQ::FFI->new();
my $frontend = $context->socket(ZMQ_ROUTER);
my $backend  = $context->socket(ZMQ_DEALER);

$frontend->bind('tcp://*:5559');
$backend->bind('tcp://*:5560');

# Switch messages between sockets

my $frontend_poller = AE::io $frontend->get_fd, 0, sub {
    while ($frontend->has_pollin) {
        my @message = $frontend->recv_multipart();
        $backend->send_multipart(\@message);
    }
};

my $backend_poller = AE::io $backend->get_fd, 0, sub {
    while ($backend->has_pollin) {
        my @message = $backend->recv_multipart();
        $frontend->send_multipart(\@message);
    }
};

EV::run;

<?php
/*
 * Simple request-reply broker
 * @author Ian Barber <ian(dot)barber(at)gmail(dot)com>
 */

//  Prepare our context and sockets
$context = new ZMQContext();
$frontend = new ZMQSocket($context, ZMQ::SOCKET_ROUTER);
$backend = new ZMQSocket($context, ZMQ::SOCKET_DEALER);
$frontend->bind("tcp://*:5559");
$backend->bind("tcp://*:5560");

//  Initialize poll set
$poll = new ZMQPoll();
$poll->add($frontend, ZMQ::POLL_IN);
$poll->add($backend, ZMQ::POLL_IN);
$readable = $writeable = array();

//  Switch messages between sockets
while (true) {
    $events = $poll->poll($readable, $writeable);

    foreach ($readable as $socket) {
        if ($socket === $frontend) {
            //  Process all parts of the message
            while (true) {
                $message = $socket->recv();
                //  Multipart detection
                $more = $socket->getSockOpt(ZMQ::SOCKOPT_RCVMORE);
                $backend->send($message, $more ? ZMQ::MODE_SNDMORE : null);
                if (!$more) {
                    break; //  Last message part
                }
            }
        } elseif ($socket === $backend) {
            $message = $socket->recv();
            //  Multipart detection
            $more = $socket->getSockOpt(ZMQ::SOCKOPT_RCVMORE);
            $frontend->send($message, $more ? ZMQ::MODE_SNDMORE : null);
            if (!$more) {
                break; //  Last message part
            }
        }
    }
}

# Simple request-reply broker
#
# Author: Lev Givon <lev(at)columbia(dot)edu>

import zmq

# Prepare our context and sockets
context = zmq.Context()
frontend = context.socket(zmq.ROUTER)
backend = context.socket(zmq.DEALER)
frontend.bind("tcp://*:5559")
backend.bind("tcp://*:5560")

# Initialize poll set
poller = zmq.Poller()
poller.register(frontend, zmq.POLLIN)
poller.register(backend, zmq.POLLIN)

# Switch messages between sockets
while True:
    socks = dict(poller.poll())

    if socks.get(frontend) == zmq.POLLIN:
        message = frontend.recv_multipart()
        backend.send_multipart(message)

    if socks.get(backend) == zmq.POLLIN:
        message = backend.recv_multipart()
        frontend.send_multipart(message)

#!/usr/bin/env ruby

# author: Oleg Sidorov <4pcbr> i4pcbr@gmail.com
# this code is licenced under the MIT/X11 licence.

require 'rubygems'
require 'ffi-rzmq'

context = ZMQ::Context.new
frontend = context.socket(ZMQ::ROUTER)
backend = context.socket(ZMQ::DEALER)

frontend.bind('tcp://*:5559')
backend.bind('tcp://*:5560')

poller = ZMQ::Poller.new
poller.register(frontend, ZMQ::POLLIN)
poller.register(backend, ZMQ::POLLIN)

loop do
  poller.poll(:blocking)
  poller.readables.each do |socket|
    if socket === frontend
      socket.recv_strings(messages = [])
      backend.send_strings(messages)
    elsif socket === backend
      socket.recv_strings(messages = [])
      frontend.send_strings(messages)
    end
  end
end

fn main() {
    let context = zmq::Context::new();
    let frontend = context.socket(zmq::ROUTER).unwrap();
    let backend = context.socket(zmq::DEALER).unwrap();
    assert!(frontend.bind("tcp://*:5559").is_ok());
    assert!(backend.bind("tcp://*:5560").is_ok());

    let items = &mut [
        frontend.as_poll_item(zmq::POLLIN),
        backend.as_poll_item(zmq::POLLIN),
    ];

    loop {
        zmq::poll(items, -1).unwrap();
        if items[0].is_readable() {
            loop {
                let message = frontend.recv_msg(0).unwrap();
                let more = if frontend.get_rcvmore().unwrap() {
                    zmq::SNDMORE
                } else {
                    0
                };
                backend.send(message, more).unwrap();
                if more == 0 {
                    break;
                };
            }
        }
        if items[1].is_readable() {
            loop {
                let message = backend.recv_msg(0).unwrap();
                let more = if backend.get_rcvmore().unwrap() {
                    zmq::SNDMORE
                } else {
                    0
                };
                frontend.send(message, more).unwrap();
                if more == 0 {
                    break;
                }
            }
        }
    }
}

/*
 * Simple request-reply broker
 *
 * @author Giovanni Ruggiero
 * @email giovanni.ruggiero@gmail.com
 *
 */

import org.zeromq.ZMQ

object rrbroker  {
  def main(args : Array[String]) {
		//  Prepare our context and sockets
		val context = ZMQ.context(1)

		val frontend = context.socket(ZMQ.ROUTER)
		val backend  = context.socket(ZMQ.DEALER)
		frontend.bind("tcp://*:5559")
		backend.bind("tcp://*:5560")

		System.out.println("launch and connect broker.")

		//  Initialize poll set
		val items = context.poller(2)
		items.register(frontend, 1)
		items.register(backend, 1)

		var more = false

		//  Switch messages between sockets
		while (!Thread.currentThread().isInterrupted()) {
			//  poll and memorize multipart detection
			items.poll()

			if (items.pollin(0)) {
			do {
				// receive message
				val message = frontend.recv(0)
				more = frontend.hasReceiveMore

				// Broker it
				if (more)
					backend.send(message, ZMQ.SNDMORE)
				else
					backend.send(message, 0)
			} while (more)
			}
			if (items.pollin(1)) {
			do {
				// receive message
				val message = backend.recv(0)
				more = backend.hasReceiveMore()
				// Broker it
				if (more)
					frontend.send(message, ZMQ.SNDMORE)
				else
					frontend.send(message, 0)
			} while (more)
			}
		}
		//  We never get here but clean up anyhow
		frontend.close()
		backend.close()
		context.term()
	}
}

#
# Simple request-reply broker
#

package require zmq

# Prepare our context and sockets
zmq context context
zmq socket frontend context ROUTER
zmq socket backend context DEALER
frontend bind "tcp://*:5559"
backend bind "tcp://*:5560"

# Initialize poll set
set poll_set [list [list frontend [list POLLIN]] [list backend [list POLLIN]]]

# Switch messages between sockets
while {1} {
    set rpoll_set [zmq poll $poll_set -1]
    foreach rpoll $rpoll_set {
	switch [lindex $rpoll 0] {
	    frontend {
		if {"POLLIN" in [lindex $rpoll 1]} {
		    while {1} {
			# Process all parts of the message
			zmq message message
			frontend recv_msg message
			set more [frontend getsockopt RCVMORE]
			backend send_msg message [expr {$more?"SNDMORE":""}]
			message close
			if {!$more} {
			    break ; # Last message part
			}
		    }
		}
	    }
	    backend {
		if {"POLLIN" in [lindex $rpoll 1]} {
		    while {1} {
			# Process all parts of the message
			zmq message message
			backend recv_msg message
			set more [backend getsockopt RCVMORE]
			frontend send_msg message [expr {$more?"SNDMORE":""}]
			message close
			if {!$more} {
			    break ; # Last message part
			}
		    }
		}
	    }
	}
    }
}

# We never get here but clean up anyhow
frontend close
backend close
context term

(* Simple request-reply broker *)

open Zmq
open Helpers

let () =
    (* Prepare our context and sockets *)
    with_context @@ fun ctx ->

    with_socket ctx Socket.router @@ fun frontend ->
    with_socket ctx Socket.dealer @@ fun backend ->
    Socket.bind frontend "tcp://*:5559";
    Socket.bind backend "tcp://*:5560";

    (* Create a router-dealer proxy *)
    Proxy.create frontend backend;

//  Simple message queuing broker
//  Same as request-reply broker but using shared queue proxy

#include "zhelpers.h"

int main (void) 
{
    void *context = zmq_ctx_new ();

    //  Socket facing clients
    void *frontend = zmq_socket (context, ZMQ_ROUTER);
    int rc = zmq_bind (frontend, "tcp://*:5559");
    assert (rc == 0);

    //  Socket facing services
    void *backend = zmq_socket (context, ZMQ_DEALER);
    rc = zmq_bind (backend, "tcp://*:5560");
    assert (rc == 0);

    //  Start the proxy
    zmq_proxy (frontend, backend, NULL);

    //  We never get here...
    zmq_close (frontend);
    zmq_close (backend);
    zmq_ctx_destroy (context);
    return 0;
}

//
//  Simple message queuing broker in C++
//  Same as request-reply broker but using QUEUE device
//

#include "zhelpers.hpp"

int main (int argc, char *argv[])
{
    zmq::context_t context(1);

    //  Socket facing clients
    zmq::socket_t frontend (context, ZMQ_ROUTER);
    frontend.bind("tcp://*:5559");

    //  Socket facing services
    zmq::socket_t backend (context, ZMQ_DEALER);
    backend.bind("tcp://*:5560");

    //  Start the proxy
    zmq::proxy(static_cast<void*>(frontend),
               static_cast<void*>(backend),
               nullptr);
    return 0;
}

;;; -*- Mode:Lisp; Syntax:ANSI-Common-Lisp; -*-
;;;
;;;  Simple message queuing broker in Common Lisp
;;;  Same as request-reply broker but using QUEUE device
;;;
;;; Kamil Shakirov <kamils80@gmail.com>
;;;

(defpackage #:zguide.msgqueue
  (:nicknames #:msgqueue)
  (:use #:cl #:zhelpers)
  (:export #:main))

(in-package :zguide.msgqueue)

(defun main ()
  (zmq:with-context (context 1)
    ;; Socket facing clients
    (zmq:with-socket (frontend context zmq:router)
      (zmq:bind frontend "tcp://*:5559")
      ;; Socket facing services
      (zmq:with-socket (backend context zmq:dealer)
        (zmq:bind backend  "tcp://*:5560")

        ;; Start built-in device
        (zmq:device zmq:queue frontend backend))))

  (cleanup))

#!/usr/bin/env escript
%%
%% Simple message queuing broker
%% Same as request-reply broker but using QUEUE device
%%

main(_) ->
    {ok, Context} = erlzmq:context(),

    %% Socket facing clients
    {ok, Frontend} = erlzmq:socket(Context, [router, {active, true}]),
    ok = erlzmq:bind(Frontend, "tcp://*:5559"),

    %% Socket facing services
    {ok, Backend} = erlzmq:socket(Context, [dealer, {active, true}]),
    ok = erlzmq:bind(Backend, "tcp://*:5560"),

    %% Start built-in device
    erlzmq_device:queue(Frontend, Backend),

    %% We never get here...
    ok = erlzmq:close(Frontend),
    ok = erlzmq:close(Backend),
    ok = erlzmq:term(Context).

defmodule msgqueue do
  @moduledoc """
  Generated by erl2ex (http://github.com/dazuma/erl2ex)
  From Erlang source: (Unknown source file)
  At: 2019-12-20 13:57:26

  """

  def main(_) do
    {:ok, context} = :erlzmq.context()
    {:ok, frontend} = :erlzmq.socket(context, [:router, {:active, true}])
    :ok = :erlzmq.bind(frontend, 'tcp://*:5559')
    {:ok, backend} = :erlzmq.socket(context, [:dealer, {:active, true}])
    :ok = :erlzmq.bind(backend, 'tcp://*:5560')
    :erlzmq_device.queue(frontend, backend)
    :ok = :erlzmq.close(frontend)
    :ok = :erlzmq.close(backend)
    :ok = :erlzmq.term(context)
  end

end

// Simple message queuing broker
// Same as request-reply broker but using QUEUE device
//
// Author:  Brendan Mc.
// Requires: http://github.com/alecthomas/gozmq

package main

import (
	zmq "github.com/alecthomas/gozmq"
)

func main() {
	context, _ := zmq.NewContext()
	defer context.Close()

	// Socket facing clients
	frontend, _ := context.NewSocket(zmq.ROUTER)
	defer frontend.Close()
	frontend.Bind("tcp://*:5559")

	// Socket facing services
	backend, _ := context.NewSocket(zmq.DEALER)
	defer backend.Close()
	backend.Bind("tcp://*:5560")

	// Start built-in device
	zmq.Device(zmq.QUEUE, frontend, backend)

	// We never get here...
}

--  Simple message queuing broker
--  Same as request-reply broker but using shared queue proxy

module Main where

import System.ZMQ4.Monadic

main :: IO ()
main = runZMQ $ do
    -- Socket facing clients
    frontend <- socket Router
    bind frontend "tcp://*:5559"

    backend <- socket Dealer
    bind backend "tcp://*:5560"

    -- Start the proxy
    proxy frontend backend Nothing

package ;

import org.zeromq.ZMQ;
import org.zeromq.ZMQSocket;
import org.zeromq.ZMQDevice;
import org.zeromq.ZContext;
import neko.Lib;

/**
 * Simple message queuing broker
 * Same as request-reply broker but using QUEUE device
 * See: http://zguide.zeromq.org/page:all#Built-in-Devices
 * 
 * Use with RrClient and RrServer
 */
class MsgQueue 
{

	public static function main() {
        var context:ZContext = new ZContext();
        Lib.println("** MsgQueue (see: http://zguide.zeromq.org/page:all#Built-in-Devices)");
        
        // Socket facing clients
        var frontend:ZMQSocket = context.createSocket(ZMQ_ROUTER);
        frontend.bind("tcp://*:5559");
        
        // Socket facing services
        var backend:ZMQSocket = context.createSocket(ZMQ_DEALER);
        backend.bind("tcp://*:5560");
		
		// Start build-in device
		var device = new ZMQDevice(ZMQ_QUEUE, frontend, backend);
		
		// We never get here
		context.destroy();
		
	}
}

package guide;

import org.zeromq.SocketType;
import org.zeromq.ZMQ;
import org.zeromq.ZMQ.Socket;
import org.zeromq.ZContext;

/**
* Simple message queuing broker
* Same as request-reply broker but using QUEUE device.
*/
public class msgqueue
{

    public static void main(String[] args)
    {
        //  Prepare our context and sockets
        try (ZContext context = new ZContext()) {
            //  Socket facing clients
            Socket frontend = context.createSocket(SocketType.ROUTER);
            frontend.bind("tcp://*:5559");

            //  Socket facing services
            Socket backend = context.createSocket(SocketType.DEALER);
            backend.bind("tcp://*:5560");

            //  Start the proxy
            ZMQ.proxy(frontend, backend, null);
        }
    }
}

--
--  Simple message queuing broker
--  Same as request-reply broker but using QUEUE device
--
--  Author: Robert G. Jakabosky <bobby@sharedrealm.com>
--
require"zmq"
require"zhelpers"

local context = zmq.init(1)

--  Socket facing clients
local frontend = context:socket(zmq.ROUTER)
frontend:bind("tcp://*:5559")

--  Socket facing services
local backend = context:socket(zmq.DEALER)
backend:bind("tcp://*:5560")

--  Start built-in device
zmq.device(zmq.QUEUE, frontend, backend)

--  We never get here...
frontend:close()
backend:close()
context:term()

//  Simple message queuing broker
//  Same as request-reply broker but using shared queue proxy

var zmq = require('zeromq');

//  Socket facing clients
var frontend = zmq.socket('router');
console.log('binding frontend...');
frontend.bindSync('tcp://*:5559');

//  Socket facing services
var backend = zmq.socket('dealer');
console.log('binding backend...');
backend.bindSync('tcp://*:5560');

//  Start the proxy
console.log('starting proxy...');
zmq.proxy(frontend, backend, null);

process.on('SIGINT', function() {
  frontend.close();
  backend.close();
});

# Simple message queuing broker in Perl
# Same as request-reply broker but using shared queue proxy

use strict;
use warnings;
use v5.10;

use ZMQ::FFI;
use ZMQ::FFI::Constants qw(ZMQ_ROUTER ZMQ_DEALER);

my $context = ZMQ::FFI->new();

# Socket facing clients
my $frontend = $context->socket(ZMQ_ROUTER);
$frontend->bind('tcp://*:5559');

# Socket facing services
my $backend = $context->socket(ZMQ_DEALER);
$backend->bind('tcp://*:5560');

# Start the proxy
$context->proxy($frontend, $backend);

# We never get here...

<?php

/*
 *  Simple message queuing broker
 *  Same as request-reply broker but using QUEUE device
 * @author Ian Barber <ian(dot)barber(at)gmail(dot)com>
 */

$context = new ZMQContext();

//  Socket facing clients
$frontend = $context->getSocket(ZMQ::SOCKET_ROUTER);
$frontend->bind("tcp://*:5559");

//  Socket facing services
$backend = $context->getSocket(ZMQ::SOCKET_DEALER);
$backend->bind("tcp://*:5560");

//  Start built-in device
$device = new ZMQDevice($frontend, $backend);
$device->run();

//  We never get here...

"""

   Simple message queuing broker
   Same as request-reply broker but using ``zmq.proxy``

   Author: Guillaume Aubert (gaubert) <guillaume(dot)aubert(at)gmail(dot)com>

"""


import zmq


def main():
    """ main method """

    context = zmq.Context()

    # Socket facing clients
    frontend = context.socket(zmq.ROUTER)
    frontend.bind("tcp://*:5559")

    # Socket facing services
    backend  = context.socket(zmq.DEALER)
    backend.bind("tcp://*:5560")

    zmq.proxy(frontend, backend)

    # We never get here...
    frontend.close()
    backend.close()
    context.term()


if __name__ == "__main__":
    main()

#!/usr/bin/env ruby

#
# Simple message queuing broke
# Same as request-reply broker but using QUEUE device
#

require 'rubygems'
require 'ffi-rzmq'

context = ZMQ::Context.new

# Socket facing clients
frontend = context.socket(ZMQ::ROUTER)
frontend.bind('tcp://*:5559')

# Socket facing services
backend = context.socket(ZMQ::DEALER)
backend.bind('tcp://*:5560')

# Start built-in device
poller = ZMQ::Device.new(frontend,backend)

fn main() {
    let context = zmq::Context::new();

    let frontend = context.socket(zmq::ROUTER).unwrap();
    assert!(frontend.bind("tcp://*:5559").is_ok());

    let backend = context.socket(zmq::DEALER).unwrap();
    assert!(backend.bind("tcp://*:5560").is_ok());

    zmq::proxy(&frontend, &backend).unwrap();
}

#
#  Simple message queuing broker
#  Same as request-reply broker but using QUEUE device
#

package require zmq

zmq context context

#  Socket facing clients
zmq socket frontend context ROUTER
frontend bind "tcp://*:5559"

#  Socket facing services
zmq socket backend context DEALER
backend bind "tcp://*:5560"

#  Start built-in device
zmq device QUEUE frontend backend

#  We never get here…
frontend close
backend close
context term

//  Weather proxy device

#include "zhelpers.h"

int main (void)
{
    void *context = zmq_ctx_new ();

    //  This is where the weather server sits
    void *frontend = zmq_socket (context, ZMQ_XSUB);
    zmq_connect (frontend, "tcp://192.168.55.210:5556");

    //  This is our public endpoint for subscribers
    void *backend = zmq_socket (context, ZMQ_XPUB);
    zmq_bind (backend, "tcp://10.1.1.0:8100");

    //  Run the proxy until the user interrupts us
    zmq_proxy (frontend, backend, NULL);
    
    zmq_close (frontend);
    zmq_close (backend);
    zmq_ctx_destroy (context);
    return 0;
}

//
//  Weather proxy device C++
//

#include "zhelpers.hpp"

int main (int argc, char *argv[])
{
    zmq::context_t context(1);

    //  This is where the weather server sits
    zmq::socket_t frontend(context, ZMQ_SUB);
    frontend.connect("tcp://192.168.55.210:5556");

    //  This is our public endpoint for subscribers
    zmq::socket_t backend (context, ZMQ_PUB);
    backend.bind("tcp://10.1.1.0:8100");

    //  Subscribe on everything
    frontend.set(zmq::sockopt::subscribe, "");

    //  Shunt messages out to our own subscribers
    while (1) {
        while (1) {
            zmq::message_t message;
            int more;
            size_t more_size = sizeof (more);

            //  Process all parts of the message
            frontend.recv(&message);
            frontend.getsockopt( ZMQ_RCVMORE, &more, &more_size);
            backend.send(message, more? ZMQ_SNDMORE: 0);
            if (!more)
                break;      //  Last message part
        }
    }
    return 0;
}

;;; -*- Mode:Lisp; Syntax:ANSI-Common-Lisp; -*-
;;;
;;;  Weather proxy device in Common Lisp
;;;
;;; Kamil Shakirov <kamils80@gmail.com>
;;;

(defpackage #:zguide.wuproxy
  (:nicknames #:wuproxy)
  (:use #:cl #:zhelpers)
  (:export #:main))

(in-package :zguide.wuproxy)

(defun main ()
  (zmq:with-context (context 1)
    ;; This is where the weather server sits
    (zmq:with-socket (frontend context zmq:sub)
      (zmq:connect frontend "tcp://192.168.55.210:5556")

      ;; This is our public endpoint for subscribers
      (zmq:with-socket (backend context zmq:pub)
        (zmq:bind backend "tcp://10.1.1.0:8100")

        ;; Subscribe on everything
        (zmq:setsockopt frontend zmq:subscribe "")

        ;; Shunt messages out to our own subscribers
        (loop
          (loop
            ;; Process all parts of the message
           (let ((message (make-instance 'zmq:msg)))
             (zmq:recv frontend message)

             (if (not (zerop (zmq:getsockopt frontend zmq:rcvmore)))
                 (zmq:send backend message zmq:sndmore)
                 (progn
                   (zmq:send backend message 0)
                   ;; Last message part
                   (return)))))))))

  (cleanup))

#! /usr/bin/env escript
%%
%% Weather proxy device
%%

main(_) ->
    {ok, Context} = erlzmq:context(),

    %% This is where the weather server sits
    {ok, Frontend} = erlzmq:socket(Context, sub),
    ok = erlzmq:connect(Frontend, "tcp://localhost:5556"),

    %% This is our public endpoint for subscribers
    {ok, Backend} = erlzmq:socket(Context, pub),
    ok = erlzmq:bind(Backend, "tcp://*:8100"),

    %% Subscribe on everything
    ok = erlzmq:setsockopt(Frontend, subscribe, <<>>),

    %% Shunt messages out to our own subscribers
    loop(Frontend, Backend),

    %% We don't actually get here but if we did, we'd shut down neatly
    ok = erlzmq:close(Frontend),
    ok = erlzmq:close(Backend),
    ok = erlzmq:term(Context).

loop(Frontend, Backend) ->
    {ok, Msg} = erlzmq:recv(Frontend),
    case erlzmq:getsockopt(Frontend, rcvmore) of
        {ok, true} -> erlzmq:send(Backend, Msg, [sndmore]);
        {ok, false} -> erlzmq:send(Backend, Msg)
    end,
    loop(Frontend, Backend).