update to 4.1.3

- ipv6 patch included upstream
- refresh zmq.hpp

.gitignore

@@ -8,3 +8,4 @@ zeromq-2.0.7.tar.gz
 /zeromq-2.2.0.tar.gz
 /zeromq-4.0.5.tar.gz
 /zeromq-4.1.2.tar.gz
+/zeromq-4.1.3.tar.gz

sources

@@ -1 +1 @@
-159c0c56a895472f02668e692d122685  zeromq-4.1.2.tar.gz
+d0824317348cfb44b8692e19cc73dc3a  zeromq-4.1.3.tar.gz

zeromq-4.1.2-ipv6.patch

@@ -1,43 +0,0 @@
-From 81464652d2453c608bbbb52fd59e9e9f20857178 Mon Sep 17 00:00:00 2001
-From: Constantin Rack <constantin@rack.li>
-Date: Tue, 23 Jun 2015 08:29:36 +0200
-Subject: [PATCH] Solution: allow brackets in tcp address. Fixes #43
-
----
- src/socket_base.cpp            | 5 +++--
- tests/test_connect_resolve.cpp | 3 +++
- 2 files changed, 6 insertions(+), 2 deletions(-)
-
-diff --git a/src/socket_base.cpp b/src/socket_base.cpp
-index bff7068..f79af6f 100644
---- a/src/socket_base.cpp
-+++ b/src/socket_base.cpp
-@@ -603,11 +603,12 @@ int zmq::socket_base_t::connect (const char *addr_)
-         //  Following code is quick and dirty check to catch obvious errors,
-         //  without trying to be fully accurate.
-         const char *check = address.c_str ();
--        if (isalnum (*check) || isxdigit (*check)) {
-+        if (isalnum (*check) || isxdigit (*check) || *check == '[') {
-             check++;
-             while (isalnum  (*check)
-                 || isxdigit (*check)
--                || *check == '.' || *check == '-' || *check == ':'|| *check == ';')
-+                || *check == '.' || *check == '-' || *check == ':'|| *check == ';'
-+                || *check == ']')
-                 check++;
-         }
-         //  Assume the worst, now look for success
-diff --git a/tests/test_connect_resolve.cpp b/tests/test_connect_resolve.cpp
-index f9a7b9d..cb5353f 100644
---- a/tests/test_connect_resolve.cpp
-+++ b/tests/test_connect_resolve.cpp
-@@ -41,6 +41,9 @@ int main (void)
-     int rc = zmq_connect (sock, "tcp://localhost:1234");
-     assert (rc == 0);
- 
-+    rc = zmq_connect (sock, "tcp://[::1]:4506");
-+    assert (rc == 0);
-+
-     rc = zmq_connect (sock, "tcp://localhost:invalid");
-     assert (rc == -1);
- 

zeromq.spec

@@ -1,7 +1,7 @@
 %bcond_without pgm
 
 Name:           zeromq
-Version:        4.1.2
+Version:        4.1.3
 Release:        1%{?dist}
 Summary:        Software library for fast, message-based applications
 
@@ -10,7 +10,6 @@ License:        LGPLv3+
 URL:            http://www.zeromq.org
 # VCS:          git:http://github.com/zeromq/zeromq2.git
 Source0:        http://download.zeromq.org/zeromq-%{version}.tar.gz
-Patch0:         zeromq-4.1.2-ipv6.patch
 Source1:        https://raw.githubusercontent.com/zeromq/cppzmq/master/zmq.hpp
 Source2:        https://raw.githubusercontent.com/zeromq/cppzmq/master/LICENSE
 
@@ -66,7 +65,6 @@ developing applications that use the C++ header files of %{name}.
 
 %prep
 %setup -q
-%patch0 -p1
 cp -a %{SOURCE2} .
 
 # zeromq.x86_64: W: file-not-utf8 /usr/share/doc/zeromq/ChangeLog
@@ -130,6 +128,11 @@ make check V=1
 
 
 %changelog
+* Mon Aug 24 2015 Thomas Spura <tomspur@fedoraproject.org> - 4.1.3-1
+- update to 4.1.3 (#1256209)
+- ipv6 patch included upstream
+- refresh zmq.hpp
+
 * Tue Jun 23 2015 Thomas Spura <tomspur@fedoraproject.org> - 4.1.2-1
 - update to 4.1.2
 - add upstream patch to fix problem with ipv6

zmq.hpp

@@ -25,6 +25,16 @@
 #ifndef __ZMQ_HPP_INCLUDED__
 #define __ZMQ_HPP_INCLUDED__
 
+#if __cplusplus >= 201103L
+#define ZMQ_CPP11
+#define ZMQ_NOTHROW noexcept
+#define ZMQ_EXPLICIT explicit
+#else
+    #define ZMQ_CPP03
+    #define ZMQ_NOTHROW
+    #define ZMQ_EXPLICIT
+#endif
+
 #include <zmq.h>
 
 #include <algorithm>
@@ -32,6 +42,13 @@
 #include <cstring>
 #include <string>
 #include <exception>
+#include <vector>
+#include <iterator>
+
+#ifdef ZMQ_CPP11
+#include <chrono>
+#include <tuple>
+#endif
 
 //  Detect whether the compiler supports C++11 rvalue references.
 #if (defined(__GNUC__) && (__GNUC__ > 4 || \
@@ -104,14 +121,38 @@ namespace zmq
         int errnum;
     };
 
-    inline int poll (zmq_pollitem_t *items_, int nitems_, long timeout_ = -1)
+    inline int poll (zmq_pollitem_t const* items_, int nitems_, long timeout_ = -1)
     {
-        int rc = zmq_poll (items_, nitems_, timeout_);
+        int rc = zmq_poll (const_cast<zmq_pollitem_t*>(items_), nitems_, timeout_);
         if (rc < 0)
             throw error_t ();
         return rc;
     }
 
+    inline int poll(zmq_pollitem_t const* items, size_t nitems)
+    {
+        return poll(items, nitems, -1 );
+    }
+
+    #ifdef ZMQ_CPP11
+    inline int poll(zmq_pollitem_t const* items, size_t nitems, std::chrono::milliseconds timeout)
+    {
+        return poll(items, nitems, timeout.count() );
+    }
+
+    inline int poll(std::vector<zmq_pollitem_t> const& items, std::chrono::milliseconds timeout)
+    {
+        return poll(items.data(), items.size(), timeout.count() );
+    }
+    #endif
+
+    inline int poll(std::vector<zmq_pollitem_t> const& items, long timeout_ = -1)
+    {
+        return poll(items.data(), items.size(), timeout_);
+    }
+
+
+
     inline void proxy (void *frontend, void *backend, void *capture)
     {
         int rc = zmq_proxy (frontend, backend, capture);
@@ -133,6 +174,15 @@ namespace zmq
         zmq_version (major_, minor_, patch_);
     }
 
+    #ifdef ZMQ_CPP11
+    inline std::tuple<int, int, int> version()
+    {
+        std::tuple<int, int, int> v;
+        zmq_version(&std::get<0>(v), &std::get<1>(v), &std::get<2>(v) );
+        return v;
+    }
+    #endif
+
     class message_t
     {
         friend class socket_t;
@@ -153,6 +203,19 @@ namespace zmq
                 throw error_t ();
         }
 
+        template<typename I> message_t(I first, I last):
+            msg()
+        {
+            typedef typename std::iterator_traits<I>::difference_type size_type;
+            typedef typename std::iterator_traits<I>::pointer pointer_t;
+
+            size_type const size_ = std::distance(first, last);
+            int const rc = zmq_msg_init_size (&msg, size_);
+            if (rc != 0)
+                throw error_t ();
+            std::copy(first, last, static_cast<pointer_t>(zmq_msg_data (&msg)) );
+        }
+
         inline message_t (void *data_, size_t size_, free_fn *ffn_,
             void *hint_ = NULL)
         {
@@ -162,21 +225,21 @@ namespace zmq
         }
 
 #ifdef ZMQ_HAS_RVALUE_REFS
-        inline message_t (message_t &&rhs) : msg (rhs.msg)
+        inline message_t (message_t &&rhs): msg (rhs.msg)
         {
             int rc = zmq_msg_init (&rhs.msg);
             if (rc != 0)
                 throw error_t ();
         }
 
-        inline message_t &operator = (message_t &&rhs)
+        inline message_t &operator = (message_t &&rhs) ZMQ_NOTHROW
         {
             std::swap (msg, rhs.msg);
             return *this;
         }
 #endif
 
-        inline ~message_t ()
+        inline ~message_t () ZMQ_NOTHROW
         {
             int rc = zmq_msg_close (&msg);
             ZMQ_ASSERT (rc == 0);
@@ -213,50 +276,60 @@ namespace zmq
                 throw error_t ();
         }
 
-        inline void move (message_t *msg_)
+        inline void move (message_t const *msg_)
         {
-            int rc = zmq_msg_move (&msg, &(msg_->msg));
+            int rc = zmq_msg_move (&msg, const_cast<zmq_msg_t*>(&(msg_->msg)));
             if (rc != 0)
                 throw error_t ();
         }
 
-        inline void copy (message_t *msg_)
+        inline void copy (message_t const *msg_)
         {
-            int rc = zmq_msg_copy (&msg, &(msg_->msg));
+            int rc = zmq_msg_copy (&msg, const_cast<zmq_msg_t*>(&(msg_->msg)));
             if (rc != 0)
                 throw error_t ();
         }
 
-        inline bool more ()
+        inline bool more () const ZMQ_NOTHROW
         {
-            int rc = zmq_msg_more (&msg);
+            int rc = zmq_msg_more (const_cast<zmq_msg_t*>(&msg) );
             return rc != 0;
         }
 
-        inline void *data ()
+        inline void *data () ZMQ_NOTHROW
         {
             return zmq_msg_data (&msg);
         }
 
-        inline const void* data () const
+        inline const void* data () const ZMQ_NOTHROW
         {
             return zmq_msg_data (const_cast<zmq_msg_t*>(&msg));
         }
 
-        inline size_t size () const
+        inline size_t size () const ZMQ_NOTHROW
         {
             return zmq_msg_size (const_cast<zmq_msg_t*>(&msg));
         }
 
-    private:
+        template<typename T> T* data() ZMQ_NOTHROW
+        {
+            return static_cast<T*>( data() );
+        }
+
+        template<typename T> T const* data() const ZMQ_NOTHROW
+        {
+            return static_cast<T const*>( data() );
+        }
+
 
+    private:
         //  The underlying message
         zmq_msg_t msg;
 
         //  Disable implicit message copying, so that users won't use shared
         //  messages (less efficient) without being aware of the fact.
-        message_t (const message_t&);
+        message_t (const message_t&) ZMQ_DELETED_FUNCTION;
-        void operator = (const message_t&);
+        void operator = (const message_t&) ZMQ_DELETED_FUNCTION;
     };
 
     class context_t
@@ -286,23 +359,23 @@ namespace zmq
         }
 
 #ifdef ZMQ_HAS_RVALUE_REFS
-        inline context_t (context_t &&rhs) : ptr (rhs.ptr)
+        inline context_t (context_t &&rhs) ZMQ_NOTHROW : ptr (rhs.ptr)
         {
             rhs.ptr = NULL;
         }
-        inline context_t &operator = (context_t &&rhs)
+        inline context_t &operator = (context_t &&rhs) ZMQ_NOTHROW
         {
             std::swap (ptr, rhs.ptr);
             return *this;
         }
 #endif
 
-        inline ~context_t ()
+        inline ~context_t () ZMQ_NOTHROW
         {
             close();
         }
 
-        inline void close()
+        inline void close() ZMQ_NOTHROW
         {
             if (ptr == NULL)
                 return;
@@ -314,55 +387,85 @@ namespace zmq
         //  Be careful with this, it's probably only useful for
         //  using the C api together with an existing C++ api.
         //  Normally you should never need to use this.
-        inline operator void* ()
+        inline ZMQ_EXPLICIT operator void* () ZMQ_NOTHROW
         {
             return ptr;
         }
 
+        inline ZMQ_EXPLICIT operator void const* () const ZMQ_NOTHROW
+        {
+            return ptr;
+        }
     private:
 
         void *ptr;
 
-        context_t (const context_t&);
+        context_t (const context_t&) ZMQ_DELETED_FUNCTION;
-        void operator = (const context_t&);
+        void operator = (const context_t&) ZMQ_DELETED_FUNCTION;
+    };
+
+    #ifdef ZMQ_CPP11
+    enum class socket_type: int
+    {
+        req = ZMQ_REQ,
+        rep = ZMQ_REP,
+        dealer = ZMQ_DEALER,
+        router = ZMQ_ROUTER,
+        pub = ZMQ_PUB,
+        sub = ZMQ_SUB,
+        xpub = ZMQ_XPUB,
+        xsub = ZMQ_XSUB,
+        push = ZMQ_PUSH,
+        pull = ZMQ_PULL,
+        pair = ZMQ_PAIR,
+        stream = ZMQ_STREAM
     };
+    #endif
 
     class socket_t
     {
         friend class monitor_t;
     public:
+        inline socket_t(context_t& context_, int type_)
+        {
+            init(context_, type_);
+        }
 
-        inline socket_t (context_t &context_, int type_)
+        #ifdef ZMQ_CPP11
+        inline socket_t(context_t& context_, socket_type type_)
         {
-            ctxptr = context_.ptr;
+            init(context_, static_cast<int>(type_));
-            ptr = zmq_socket (context_.ptr, type_);
-            if (ptr == NULL)
-                throw error_t ();
         }
+        #endif
 
 #ifdef ZMQ_HAS_RVALUE_REFS
-        inline socket_t(socket_t&& rhs) : ptr(rhs.ptr)
+        inline socket_t(socket_t&& rhs) ZMQ_NOTHROW : ptr(rhs.ptr)
         {
             rhs.ptr = NULL;
         }
-        inline socket_t& operator=(socket_t&& rhs)
+        inline socket_t& operator=(socket_t&& rhs) ZMQ_NOTHROW
         {
             std::swap(ptr, rhs.ptr);
             return *this;
         }
 #endif
 
-        inline ~socket_t ()
+        inline ~socket_t () ZMQ_NOTHROW
         {
             close();
         }
 
-        inline operator void* ()
+        inline ZMQ_EXPLICIT operator void* () ZMQ_NOTHROW
         {
             return ptr;
         }
 
-        inline void close()
+        inline ZMQ_EXPLICIT operator void const* () const ZMQ_NOTHROW
+        {
+            return ptr;
+        }
+
+        inline void close() ZMQ_NOTHROW
         {
             if(ptr == NULL)
                 // already closed
@@ -372,6 +475,11 @@ namespace zmq
             ptr = 0 ;
         }
 
+        template<typename T> void setsockopt(int option_, T const& optval)
+        {
+            setsockopt(option_, &optval, sizeof(T) );
+        }
+
         inline void setsockopt (int option_, const void *optval_,
             size_t optvallen_)
         {
@@ -388,6 +496,19 @@ namespace zmq
                 throw error_t ();
         }
 
+        template<typename T> T getsockopt(int option_)
+        {
+            T optval;
+            size_t optlen = sizeof(T);
+            getsockopt(option_, &optval, &optlen );
+            return optval;
+        }
+
+        inline void bind(std::string const& addr)
+        {
+            bind(addr.c_str());
+        }
+
         inline void bind (const char *addr_)
         {
             int rc = zmq_bind (ptr, addr_);
@@ -395,6 +516,11 @@ namespace zmq
                 throw error_t ();
         }
 
+        inline void unbind(std::string const& addr)
+        {
+            unbind(addr.c_str());
+        }
+
         inline void unbind (const char *addr_)
         {
             int rc = zmq_unbind (ptr, addr_);
@@ -402,6 +528,11 @@ namespace zmq
                 throw error_t ();
         }
 
+        inline void connect(std::string const& addr)
+        {
+            connect(addr.c_str());
+        }
+
         inline void connect (const char *addr_)
         {
             int rc = zmq_connect (ptr, addr_);
@@ -409,6 +540,11 @@ namespace zmq
                 throw error_t ();
         }
 
+        inline void disconnect(std::string const& addr)
+        {
+            disconnect(addr.c_str());
+        }
+
         inline void disconnect (const char *addr_)
         {
             int rc = zmq_disconnect (ptr, addr_);
@@ -416,7 +552,7 @@ namespace zmq
                 throw error_t ();
         }
 
-        inline bool connected()
+        inline bool connected() const ZMQ_NOTHROW
         {
             return(ptr != NULL);
         }
@@ -441,6 +577,12 @@ namespace zmq
             throw error_t ();
         }
 
+        template<typename I> bool send(I first, I last, int flags_=0)
+        {
+            zmq::message_t msg(first, last);
+            return send(msg, flags_);
+        }
+
 #ifdef ZMQ_HAS_RVALUE_REFS
         inline bool send (message_t &&msg_, int flags_ = 0)
         {
@@ -469,6 +611,14 @@ namespace zmq
         }
         
     private:
+        inline void init(context_t& context_, int type_)
+        {
+            ctxptr = context_.ptr;
+            ptr = zmq_socket (context_.ptr, type_ );
+            if (ptr == NULL)
+                throw error_t ();
+        }
+
         void *ptr;
         void *ctxptr;
 
@@ -482,6 +632,11 @@ namespace zmq
         monitor_t() : socketPtr(NULL) {}
         virtual ~monitor_t() {}
 
+        void monitor(socket_t &socket, std::string const& addr, int events = ZMQ_EVENT_ALL)
+        {
+            monitor(socket, addr.c_str(), events);
+        }
+
         void monitor(socket_t &socket, const char *addr_, int events = ZMQ_EVENT_ALL)
         {
             int rc = zmq_socket_monitor(socket.ptr, addr_, events);