czmq-ffi-gen 0.10.0-x64-mingw32 → 0.12.0-x64-mingw32

Sign up to get free protection for your applications and to get access to all the features.
Files changed (43) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGES.md +8 -0
  3. data/lib/czmq-ffi-gen/czmq/ffi.rb +345 -209
  4. data/lib/czmq-ffi-gen/czmq/ffi/version.rb +1 -1
  5. data/lib/czmq-ffi-gen/czmq/ffi/zcert.rb +0 -12
  6. data/lib/czmq-ffi-gen/czmq/ffi/zcertstore.rb +0 -12
  7. data/lib/czmq-ffi-gen/czmq/ffi/zhash.rb +0 -31
  8. data/lib/czmq-ffi-gen/czmq/ffi/zhashx.rb +0 -44
  9. data/lib/czmq-ffi-gen/czmq/ffi/zsock.rb +706 -0
  10. data/lib/czmq-ffi-gen/gem_version.rb +1 -1
  11. data/vendor/local/bin/inproc_lat.exe +0 -0
  12. data/vendor/local/bin/inproc_thr.exe +0 -0
  13. data/vendor/local/bin/libczmq.dll +0 -0
  14. data/vendor/local/bin/libzmq.dll +0 -0
  15. data/vendor/local/bin/local_lat.exe +0 -0
  16. data/vendor/local/bin/local_thr.exe +0 -0
  17. data/vendor/local/bin/remote_lat.exe +0 -0
  18. data/vendor/local/bin/remote_thr.exe +0 -0
  19. data/vendor/local/include/czmq.h +8 -0
  20. data/vendor/local/include/czmq_library.h +2 -29
  21. data/vendor/local/include/zauth.h +1 -1
  22. data/vendor/local/include/zcert.h +0 -8
  23. data/vendor/local/include/zcertstore.h +0 -8
  24. data/vendor/local/include/zhash.h +0 -13
  25. data/vendor/local/include/zhashx.h +0 -21
  26. data/vendor/local/include/zloop.h +7 -12
  27. data/vendor/local/include/zpoller.h +7 -12
  28. data/vendor/local/include/zsock.h +159 -44
  29. data/vendor/local/include/zsock_option.inc +578 -0
  30. data/vendor/local/include/zsys.h +9 -0
  31. data/vendor/local/lib/libczmq.dll.a +0 -0
  32. data/vendor/local/lib/liblibzmq.dll.a +0 -0
  33. data/vendor/local/lib/pkgconfig/libczmq.pc +2 -1
  34. metadata +2 -11
  35. data/vendor/local/include/zauth_v2.h +0 -88
  36. data/vendor/local/include/zbeacon_v2.h +0 -75
  37. data/vendor/local/include/zctx.h +0 -107
  38. data/vendor/local/include/zmonitor_v2.h +0 -56
  39. data/vendor/local/include/zmutex.h +0 -55
  40. data/vendor/local/include/zproxy_v2.h +0 -62
  41. data/vendor/local/include/zsocket.h +0 -110
  42. data/vendor/local/include/zsockopt.h +0 -256
  43. data/vendor/local/include/zthread.h +0 -50
@@ -152,6 +152,373 @@ zsock_use_fd (void *self)
152
152
  # endif
153
153
  }
154
154
 
155
+ // --------------------------------------------------------------------------
156
+ // Set socket ZMQ_XPUB_MANUAL value
157
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
158
+
159
+ void
160
+ zsock_set_xpub_manual (void *self, int xpub_manual)
161
+ {
162
+ assert (self);
163
+ # if defined (ZMQ_XPUB_MANUAL)
164
+ if (zsock_type (self) != ZMQ_XPUB) {
165
+ printf ("ZMQ_XPUB_MANUAL is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
166
+ assert (false);
167
+ }
168
+ int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_XPUB_MANUAL, &xpub_manual, sizeof (int));
169
+ assert (rc == 0 || zmq_errno () == ETERM);
170
+ # endif
171
+ }
172
+
173
+
174
+ // --------------------------------------------------------------------------
175
+ // Set socket ZMQ_XPUB_WELCOME_MSG value
176
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
177
+
178
+ void
179
+ zsock_set_xpub_welcome_msg (void *self, const char * xpub_welcome_msg)
180
+ {
181
+ assert (self);
182
+ # if defined (ZMQ_XPUB_WELCOME_MSG)
183
+ if (zsock_type (self) != ZMQ_XPUB) {
184
+ printf ("ZMQ_XPUB_WELCOME_MSG is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
185
+ assert (false);
186
+ }
187
+ int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_XPUB_WELCOME_MSG, xpub_welcome_msg, strlen (xpub_welcome_msg));
188
+ assert (rc == 0 || zmq_errno () == ETERM);
189
+ # endif
190
+ }
191
+
192
+
193
+ // --------------------------------------------------------------------------
194
+ // Set socket ZMQ_STREAM_NOTIFY value
195
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
196
+
197
+ void
198
+ zsock_set_stream_notify (void *self, int stream_notify)
199
+ {
200
+ assert (self);
201
+ # if defined (ZMQ_STREAM_NOTIFY)
202
+ if (zsock_type (self) != ZMQ_STREAM) {
203
+ printf ("ZMQ_STREAM_NOTIFY is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
204
+ assert (false);
205
+ }
206
+ int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_STREAM_NOTIFY, &stream_notify, sizeof (int));
207
+ assert (rc == 0 || zmq_errno () == ETERM);
208
+ # endif
209
+ }
210
+
211
+
212
+ // --------------------------------------------------------------------------
213
+ // Set socket ZMQ_INVERT_MATCHING value
214
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
215
+
216
+ void
217
+ zsock_set_invert_matching (void *self, int invert_matching)
218
+ {
219
+ assert (self);
220
+ # if defined (ZMQ_INVERT_MATCHING)
221
+ if (zsock_type (self) != ZMQ_XPUB
222
+ && zsock_type (self) != ZMQ_PUB
223
+ && zsock_type (self) != ZMQ_SUB) {
224
+ printf ("ZMQ_INVERT_MATCHING is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
225
+ assert (false);
226
+ }
227
+ int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_INVERT_MATCHING, &invert_matching, sizeof (int));
228
+ assert (rc == 0 || zmq_errno () == ETERM);
229
+ # endif
230
+ }
231
+
232
+
233
+ // --------------------------------------------------------------------------
234
+ // Return socket ZMQ_INVERT_MATCHING value
235
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
236
+
237
+ int
238
+ zsock_invert_matching (void *self)
239
+ {
240
+ assert (self);
241
+ # if defined (ZMQ_INVERT_MATCHING)
242
+ int invert_matching;
243
+ size_t option_len = sizeof (int);
244
+ zmq_getsockopt (zsock_resolve (self), ZMQ_INVERT_MATCHING, &invert_matching, &option_len);
245
+ return invert_matching;
246
+ # else
247
+ return 0;
248
+ # endif
249
+ }
250
+
251
+ // --------------------------------------------------------------------------
252
+ // Set socket ZMQ_XPUB_VERBOSER value
253
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
254
+
255
+ void
256
+ zsock_set_xpub_verboser (void *self, int xpub_verboser)
257
+ {
258
+ assert (self);
259
+ # if defined (ZMQ_XPUB_VERBOSER)
260
+ if (zsock_type (self) != ZMQ_XPUB) {
261
+ printf ("ZMQ_XPUB_VERBOSER is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
262
+ assert (false);
263
+ }
264
+ int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_XPUB_VERBOSER, &xpub_verboser, sizeof (int));
265
+ assert (rc == 0 || zmq_errno () == ETERM);
266
+ # endif
267
+ }
268
+
269
+
270
+ // --------------------------------------------------------------------------
271
+ // Set socket ZMQ_CONNECT_TIMEOUT value
272
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
273
+
274
+ void
275
+ zsock_set_connect_timeout (void *self, int connect_timeout)
276
+ {
277
+ assert (self);
278
+ # if defined (ZMQ_CONNECT_TIMEOUT)
279
+ int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_CONNECT_TIMEOUT, &connect_timeout, sizeof (int));
280
+ assert (rc == 0 || zmq_errno () == ETERM);
281
+ # endif
282
+ }
283
+
284
+
285
+ // --------------------------------------------------------------------------
286
+ // Return socket ZMQ_CONNECT_TIMEOUT value
287
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
288
+
289
+ int
290
+ zsock_connect_timeout (void *self)
291
+ {
292
+ assert (self);
293
+ # if defined (ZMQ_CONNECT_TIMEOUT)
294
+ int connect_timeout;
295
+ size_t option_len = sizeof (int);
296
+ zmq_getsockopt (zsock_resolve (self), ZMQ_CONNECT_TIMEOUT, &connect_timeout, &option_len);
297
+ return connect_timeout;
298
+ # else
299
+ return 0;
300
+ # endif
301
+ }
302
+
303
+ // --------------------------------------------------------------------------
304
+ // Set socket ZMQ_TCP_MAXRT value
305
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
306
+
307
+ void
308
+ zsock_set_tcp_maxrt (void *self, int tcp_maxrt)
309
+ {
310
+ assert (self);
311
+ # if defined (ZMQ_TCP_MAXRT)
312
+ int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_TCP_MAXRT, &tcp_maxrt, sizeof (int));
313
+ assert (rc == 0 || zmq_errno () == ETERM);
314
+ # endif
315
+ }
316
+
317
+
318
+ // --------------------------------------------------------------------------
319
+ // Return socket ZMQ_TCP_MAXRT value
320
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
321
+
322
+ int
323
+ zsock_tcp_maxrt (void *self)
324
+ {
325
+ assert (self);
326
+ # if defined (ZMQ_TCP_MAXRT)
327
+ int tcp_maxrt;
328
+ size_t option_len = sizeof (int);
329
+ zmq_getsockopt (zsock_resolve (self), ZMQ_TCP_MAXRT, &tcp_maxrt, &option_len);
330
+ return tcp_maxrt;
331
+ # else
332
+ return 0;
333
+ # endif
334
+ }
335
+
336
+ // --------------------------------------------------------------------------
337
+ // Return socket ZMQ_THREAD_SAFE value
338
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
339
+
340
+ int
341
+ zsock_thread_safe (void *self)
342
+ {
343
+ assert (self);
344
+ # if defined (ZMQ_THREAD_SAFE)
345
+ int thread_safe;
346
+ size_t option_len = sizeof (int);
347
+ zmq_getsockopt (zsock_resolve (self), ZMQ_THREAD_SAFE, &thread_safe, &option_len);
348
+ return thread_safe;
349
+ # else
350
+ return 0;
351
+ # endif
352
+ }
353
+
354
+ // --------------------------------------------------------------------------
355
+ // Set socket ZMQ_MULTICAST_MAXTPDU value
356
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
357
+
358
+ void
359
+ zsock_set_multicast_maxtpdu (void *self, int multicast_maxtpdu)
360
+ {
361
+ assert (self);
362
+ # if defined (ZMQ_MULTICAST_MAXTPDU)
363
+ int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_MULTICAST_MAXTPDU, &multicast_maxtpdu, sizeof (int));
364
+ assert (rc == 0 || zmq_errno () == ETERM);
365
+ # endif
366
+ }
367
+
368
+
369
+ // --------------------------------------------------------------------------
370
+ // Return socket ZMQ_MULTICAST_MAXTPDU value
371
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
372
+
373
+ int
374
+ zsock_multicast_maxtpdu (void *self)
375
+ {
376
+ assert (self);
377
+ # if defined (ZMQ_MULTICAST_MAXTPDU)
378
+ int multicast_maxtpdu;
379
+ size_t option_len = sizeof (int);
380
+ zmq_getsockopt (zsock_resolve (self), ZMQ_MULTICAST_MAXTPDU, &multicast_maxtpdu, &option_len);
381
+ return multicast_maxtpdu;
382
+ # else
383
+ return 0;
384
+ # endif
385
+ }
386
+
387
+ // --------------------------------------------------------------------------
388
+ // Set socket ZMQ_VMCI_BUFFER_SIZE value
389
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
390
+
391
+ void
392
+ zsock_set_vmci_buffer_size (void *self, int vmci_buffer_size)
393
+ {
394
+ assert (self);
395
+ # if defined (ZMQ_VMCI_BUFFER_SIZE)
396
+ uint64_t value = vmci_buffer_size;
397
+ int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_VMCI_BUFFER_SIZE, &value, sizeof (uint64_t));
398
+ assert (rc == 0 || zmq_errno () == ETERM);
399
+ # endif
400
+ }
401
+
402
+
403
+ // --------------------------------------------------------------------------
404
+ // Return socket ZMQ_VMCI_BUFFER_SIZE value
405
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
406
+
407
+ int
408
+ zsock_vmci_buffer_size (void *self)
409
+ {
410
+ assert (self);
411
+ # if defined (ZMQ_VMCI_BUFFER_SIZE)
412
+ uint64_t vmci_buffer_size;
413
+ size_t option_len = sizeof (uint64_t);
414
+ zmq_getsockopt (zsock_resolve (self), ZMQ_VMCI_BUFFER_SIZE, &vmci_buffer_size, &option_len);
415
+ return (int) vmci_buffer_size;
416
+ # else
417
+ return 0;
418
+ # endif
419
+ }
420
+
421
+ // --------------------------------------------------------------------------
422
+ // Set socket ZMQ_VMCI_BUFFER_MIN_SIZE value
423
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
424
+
425
+ void
426
+ zsock_set_vmci_buffer_min_size (void *self, int vmci_buffer_min_size)
427
+ {
428
+ assert (self);
429
+ # if defined (ZMQ_VMCI_BUFFER_MIN_SIZE)
430
+ uint64_t value = vmci_buffer_min_size;
431
+ int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_VMCI_BUFFER_MIN_SIZE, &value, sizeof (uint64_t));
432
+ assert (rc == 0 || zmq_errno () == ETERM);
433
+ # endif
434
+ }
435
+
436
+
437
+ // --------------------------------------------------------------------------
438
+ // Return socket ZMQ_VMCI_BUFFER_MIN_SIZE value
439
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
440
+
441
+ int
442
+ zsock_vmci_buffer_min_size (void *self)
443
+ {
444
+ assert (self);
445
+ # if defined (ZMQ_VMCI_BUFFER_MIN_SIZE)
446
+ uint64_t vmci_buffer_min_size;
447
+ size_t option_len = sizeof (uint64_t);
448
+ zmq_getsockopt (zsock_resolve (self), ZMQ_VMCI_BUFFER_MIN_SIZE, &vmci_buffer_min_size, &option_len);
449
+ return (int) vmci_buffer_min_size;
450
+ # else
451
+ return 0;
452
+ # endif
453
+ }
454
+
455
+ // --------------------------------------------------------------------------
456
+ // Set socket ZMQ_VMCI_BUFFER_MAX_SIZE value
457
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
458
+
459
+ void
460
+ zsock_set_vmci_buffer_max_size (void *self, int vmci_buffer_max_size)
461
+ {
462
+ assert (self);
463
+ # if defined (ZMQ_VMCI_BUFFER_MAX_SIZE)
464
+ uint64_t value = vmci_buffer_max_size;
465
+ int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_VMCI_BUFFER_MAX_SIZE, &value, sizeof (uint64_t));
466
+ assert (rc == 0 || zmq_errno () == ETERM);
467
+ # endif
468
+ }
469
+
470
+
471
+ // --------------------------------------------------------------------------
472
+ // Return socket ZMQ_VMCI_BUFFER_MAX_SIZE value
473
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
474
+
475
+ int
476
+ zsock_vmci_buffer_max_size (void *self)
477
+ {
478
+ assert (self);
479
+ # if defined (ZMQ_VMCI_BUFFER_MAX_SIZE)
480
+ uint64_t vmci_buffer_max_size;
481
+ size_t option_len = sizeof (uint64_t);
482
+ zmq_getsockopt (zsock_resolve (self), ZMQ_VMCI_BUFFER_MAX_SIZE, &vmci_buffer_max_size, &option_len);
483
+ return (int) vmci_buffer_max_size;
484
+ # else
485
+ return 0;
486
+ # endif
487
+ }
488
+
489
+ // --------------------------------------------------------------------------
490
+ // Set socket ZMQ_VMCI_CONNECT_TIMEOUT value
491
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
492
+
493
+ void
494
+ zsock_set_vmci_connect_timeout (void *self, int vmci_connect_timeout)
495
+ {
496
+ assert (self);
497
+ # if defined (ZMQ_VMCI_CONNECT_TIMEOUT)
498
+ int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_VMCI_CONNECT_TIMEOUT, &vmci_connect_timeout, sizeof (int));
499
+ assert (rc == 0 || zmq_errno () == ETERM);
500
+ # endif
501
+ }
502
+
503
+
504
+ // --------------------------------------------------------------------------
505
+ // Return socket ZMQ_VMCI_CONNECT_TIMEOUT value
506
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
507
+
508
+ int
509
+ zsock_vmci_connect_timeout (void *self)
510
+ {
511
+ assert (self);
512
+ # if defined (ZMQ_VMCI_CONNECT_TIMEOUT)
513
+ int vmci_connect_timeout;
514
+ size_t option_len = sizeof (int);
515
+ zmq_getsockopt (zsock_resolve (self), ZMQ_VMCI_CONNECT_TIMEOUT, &vmci_connect_timeout, &option_len);
516
+ return vmci_connect_timeout;
517
+ # else
518
+ return 0;
519
+ # endif
520
+ }
521
+
155
522
  // --------------------------------------------------------------------------
156
523
  // Set socket ZMQ_TOS value
157
524
  // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
@@ -204,6 +571,126 @@ zsock_set_router_handover (void *self, int router_handover)
204
571
  }
205
572
 
206
573
 
574
+ // --------------------------------------------------------------------------
575
+ // Set socket ZMQ_CONNECT_RID value
576
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
577
+
578
+ void
579
+ zsock_set_connect_rid (void *self, const char * connect_rid)
580
+ {
581
+ assert (self);
582
+ # if defined (ZMQ_CONNECT_RID)
583
+ if (zsock_type (self) != ZMQ_ROUTER
584
+ && zsock_type (self) != ZMQ_STREAM) {
585
+ printf ("ZMQ_CONNECT_RID is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
586
+ assert (false);
587
+ }
588
+ int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_CONNECT_RID, connect_rid, strlen (connect_rid));
589
+ assert (rc == 0 || zmq_errno () == ETERM);
590
+ # endif
591
+ }
592
+
593
+
594
+ // --------------------------------------------------------------------------
595
+ // Set socket ZMQ_CONNECT_RID value from 32-octet binary
596
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
597
+
598
+ void
599
+ zsock_set_connect_rid_bin (void *self, const byte *connect_rid)
600
+ {
601
+ # if defined (ZMQ_CONNECT_RID)
602
+ int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_CONNECT_RID, connect_rid, 32);
603
+ assert (rc == 0 || zmq_errno () == ETERM);
604
+ # endif
605
+ }
606
+
607
+
608
+ // --------------------------------------------------------------------------
609
+ // Set socket ZMQ_HANDSHAKE_IVL value
610
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
611
+
612
+ void
613
+ zsock_set_handshake_ivl (void *self, int handshake_ivl)
614
+ {
615
+ assert (self);
616
+ # if defined (ZMQ_HANDSHAKE_IVL)
617
+ int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_HANDSHAKE_IVL, &handshake_ivl, sizeof (int));
618
+ assert (rc == 0 || zmq_errno () == ETERM);
619
+ # endif
620
+ }
621
+
622
+
623
+ // --------------------------------------------------------------------------
624
+ // Return socket ZMQ_HANDSHAKE_IVL value
625
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
626
+
627
+ int
628
+ zsock_handshake_ivl (void *self)
629
+ {
630
+ assert (self);
631
+ # if defined (ZMQ_HANDSHAKE_IVL)
632
+ int handshake_ivl;
633
+ size_t option_len = sizeof (int);
634
+ zmq_getsockopt (zsock_resolve (self), ZMQ_HANDSHAKE_IVL, &handshake_ivl, &option_len);
635
+ return handshake_ivl;
636
+ # else
637
+ return 0;
638
+ # endif
639
+ }
640
+
641
+ // --------------------------------------------------------------------------
642
+ // Set socket ZMQ_SOCKS_PROXY value
643
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
644
+
645
+ void
646
+ zsock_set_socks_proxy (void *self, const char * socks_proxy)
647
+ {
648
+ assert (self);
649
+ # if defined (ZMQ_SOCKS_PROXY)
650
+ int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_SOCKS_PROXY, socks_proxy, strlen (socks_proxy));
651
+ assert (rc == 0 || zmq_errno () == ETERM);
652
+ # endif
653
+ }
654
+
655
+
656
+ // --------------------------------------------------------------------------
657
+ // Return socket ZMQ_SOCKS_PROXY value
658
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
659
+
660
+ char *
661
+ zsock_socks_proxy (void *self)
662
+ {
663
+ assert (self);
664
+ # if defined (ZMQ_SOCKS_PROXY)
665
+ size_t option_len = 255;
666
+ char *socks_proxy = (char *) zmalloc (option_len);
667
+ zmq_getsockopt (zsock_resolve (self), ZMQ_SOCKS_PROXY, socks_proxy, &option_len);
668
+ return (char *) socks_proxy;
669
+ # else
670
+ return NULL;
671
+ # endif
672
+ }
673
+
674
+ // --------------------------------------------------------------------------
675
+ // Set socket ZMQ_XPUB_NODROP value
676
+ // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
677
+
678
+ void
679
+ zsock_set_xpub_nodrop (void *self, int xpub_nodrop)
680
+ {
681
+ assert (self);
682
+ # if defined (ZMQ_XPUB_NODROP)
683
+ if (zsock_type (self) != ZMQ_XPUB
684
+ && zsock_type (self) != ZMQ_PUB) {
685
+ printf ("ZMQ_XPUB_NODROP is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
686
+ assert (false);
687
+ }
688
+ int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_XPUB_NODROP, &xpub_nodrop, sizeof (int));
689
+ assert (rc == 0 || zmq_errno () == ETERM);
690
+ # endif
691
+ }
692
+
693
+
207
694
  // --------------------------------------------------------------------------
208
695
  // Set socket ZMQ_ROUTER_MANDATORY value
209
696
  // *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
@@ -3362,6 +3849,68 @@ zsock_option_test (bool verbose)
3362
3849
  zsock_use_fd (self);
3363
3850
  zsock_destroy (&self);
3364
3851
  # endif
3852
+ # if defined (ZMQ_XPUB_MANUAL)
3853
+ self = zsock_new (ZMQ_XPUB);
3854
+ assert (self);
3855
+ zsock_set_xpub_manual (self, 1);
3856
+ zsock_destroy (&self);
3857
+ # endif
3858
+ # if defined (ZMQ_XPUB_WELCOME_MSG)
3859
+ self = zsock_new (ZMQ_XPUB);
3860
+ assert (self);
3861
+ zsock_set_xpub_welcome_msg (self, "welcome");
3862
+ zsock_destroy (&self);
3863
+ # endif
3864
+ # if defined (ZMQ_STREAM_NOTIFY)
3865
+ self = zsock_new (ZMQ_STREAM);
3866
+ assert (self);
3867
+ zsock_set_stream_notify (self, 1);
3868
+ zsock_destroy (&self);
3869
+ # endif
3870
+ # if defined (ZMQ_INVERT_MATCHING)
3871
+ self = zsock_new (ZMQ_XPUB);
3872
+ assert (self);
3873
+ zsock_set_invert_matching (self, 1);
3874
+ assert (zsock_invert_matching (self) == 1);
3875
+ zsock_invert_matching (self);
3876
+ zsock_destroy (&self);
3877
+ # endif
3878
+ # if defined (ZMQ_XPUB_VERBOSER)
3879
+ self = zsock_new (ZMQ_XPUB);
3880
+ assert (self);
3881
+ zsock_set_xpub_verboser (self, 1);
3882
+ zsock_destroy (&self);
3883
+ # endif
3884
+ # if defined (ZMQ_CONNECT_TIMEOUT)
3885
+ self = zsock_new (ZMQ_DEALER);
3886
+ assert (self);
3887
+ zsock_set_connect_timeout (self, 200);
3888
+ assert (zsock_connect_timeout (self) == 200);
3889
+ zsock_connect_timeout (self);
3890
+ zsock_destroy (&self);
3891
+ # endif
3892
+ # if defined (ZMQ_TCP_MAXRT)
3893
+ self = zsock_new (ZMQ_DEALER);
3894
+ assert (self);
3895
+ zsock_set_tcp_maxrt (self, 200);
3896
+ assert (zsock_tcp_maxrt (self) == 200);
3897
+ zsock_tcp_maxrt (self);
3898
+ zsock_destroy (&self);
3899
+ # endif
3900
+ # if defined (ZMQ_THREAD_SAFE)
3901
+ self = zsock_new (ZMQ_DEALER);
3902
+ assert (self);
3903
+ zsock_thread_safe (self);
3904
+ zsock_destroy (&self);
3905
+ # endif
3906
+ # if defined (ZMQ_MULTICAST_MAXTPDU)
3907
+ self = zsock_new (ZMQ_DEALER);
3908
+ assert (self);
3909
+ zsock_set_multicast_maxtpdu (self, 1400);
3910
+ assert (zsock_multicast_maxtpdu (self) == 1400);
3911
+ zsock_multicast_maxtpdu (self);
3912
+ zsock_destroy (&self);
3913
+ # endif
3365
3914
  # if defined (ZMQ_TOS)
3366
3915
  self = zsock_new (ZMQ_DEALER);
3367
3916
  assert (self);
@@ -3376,6 +3925,35 @@ zsock_option_test (bool verbose)
3376
3925
  zsock_set_router_handover (self, 1);
3377
3926
  zsock_destroy (&self);
3378
3927
  # endif
3928
+ # if defined (ZMQ_CONNECT_RID)
3929
+ self = zsock_new (ZMQ_ROUTER);
3930
+ assert (self);
3931
+ zsock_set_connect_rid (self, "ABCD");
3932
+ zsock_destroy (&self);
3933
+ # endif
3934
+ # if defined (ZMQ_HANDSHAKE_IVL)
3935
+ self = zsock_new (ZMQ_DEALER);
3936
+ assert (self);
3937
+ zsock_set_handshake_ivl (self, 200);
3938
+ assert (zsock_handshake_ivl (self) == 200);
3939
+ zsock_handshake_ivl (self);
3940
+ zsock_destroy (&self);
3941
+ # endif
3942
+ # if defined (ZMQ_SOCKS_PROXY)
3943
+ self = zsock_new (ZMQ_DEALER);
3944
+ assert (self);
3945
+ zsock_set_socks_proxy (self, "127.0.0.1");
3946
+ char *socks_proxy = zsock_socks_proxy (self);
3947
+ assert (socks_proxy);
3948
+ free (socks_proxy);
3949
+ zsock_destroy (&self);
3950
+ # endif
3951
+ # if defined (ZMQ_XPUB_NODROP)
3952
+ self = zsock_new (ZMQ_XPUB);
3953
+ assert (self);
3954
+ zsock_set_xpub_nodrop (self, 1);
3955
+ zsock_destroy (&self);
3956
+ # endif
3379
3957
  # if defined (ZMQ_ROUTER_MANDATORY)
3380
3958
  self = zsock_new (ZMQ_ROUTER);
3381
3959
  assert (self);