rbczmq 1.6.2 → 1.6.4

data/ext/zeromq/src/Makefile.am

@@ -0,0 +1,171 @@
+lib_LTLIBRARIES = libzmq.la
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = libzmq.pc
+
+include_HEADERS = ../include/zmq.h ../include/zmq_utils.h
+
+libzmq_la_SOURCES = \
+    address.hpp \
+    array.hpp \
+    atomic_counter.hpp \
+    atomic_ptr.hpp \
+    blob.hpp \
+    clock.hpp \
+    command.hpp \
+    config.hpp \
+    ctx.hpp \
+    decoder.hpp \
+    devpoll.hpp \
+    dist.hpp \
+    encoder.hpp \
+    epoll.hpp \
+    err.hpp \
+    fd.hpp \
+    fq.hpp \
+    i_encoder.hpp \
+    i_decoder.hpp \
+    i_engine.hpp \
+    i_msg_sink.hpp \
+    i_msg_source.hpp \
+    i_poll_events.hpp \
+    io_object.hpp \
+    io_thread.hpp \
+    ip.hpp \
+    ipc_address.hpp \
+    ipc_connecter.hpp \
+    ipc_listener.hpp \
+    i_engine.hpp \
+    i_poll_events.hpp \
+    kqueue.hpp \
+    lb.hpp \
+    likely.hpp \
+    mailbox.hpp \
+    msg.hpp \
+    mtrie.hpp \
+    mutex.hpp \
+    object.hpp \
+    options.hpp \
+    own.hpp \
+    pgm_receiver.hpp \
+    pgm_sender.hpp \
+    pgm_socket.hpp \
+    pipe.hpp \
+    platform.hpp \
+    poll.hpp \
+    poller.hpp \
+    poller_base.hpp \
+    pair.hpp \
+    proxy.hpp \
+    pub.hpp \
+    pull.hpp \
+    push.hpp \
+    random.hpp \
+    reaper.hpp \
+    rep.hpp \
+    req.hpp \
+    select.hpp \
+    session_base.hpp \
+    signaler.hpp \
+    socket_base.hpp \
+    stdint.hpp \
+    stream_engine.hpp \
+    sub.hpp \
+    tcp.hpp \
+    tcp_address.hpp \
+    tcp_connecter.hpp \
+    tcp_listener.hpp \
+    thread.hpp \
+    trie.hpp \
+    windows.hpp \
+    wire.hpp \
+    xpub.hpp \
+    router.hpp \
+    dealer.hpp \
+    xsub.hpp \
+    ypipe.hpp \
+    yqueue.hpp \
+    address.cpp \
+    clock.cpp \
+    ctx.cpp \
+    decoder.cpp \
+    devpoll.cpp \
+    dist.cpp \
+    encoder.cpp \
+    epoll.cpp \
+    err.cpp \
+    fq.cpp \
+    io_object.cpp \
+    io_thread.cpp \
+    ip.cpp \
+    ipc_address.cpp \
+    ipc_connecter.cpp \
+    ipc_listener.cpp \
+    kqueue.cpp \
+    lb.cpp \
+    mailbox.cpp \
+    msg.cpp \
+    mtrie.cpp \
+    object.cpp \
+    options.cpp \
+    own.cpp \
+    pair.cpp \
+    pgm_receiver.cpp \
+    pgm_sender.cpp \
+    pgm_socket.cpp \
+    pipe.cpp \
+    poll.cpp \
+    poller_base.cpp \
+    pull.cpp \
+    push.cpp \
+    proxy.cpp \
+    reaper.cpp \
+    pub.cpp \
+    random.cpp \
+    rep.cpp \
+    req.cpp \
+    select.cpp \
+    session_base.cpp \
+    signaler.cpp \
+    socket_base.cpp \
+    stream_engine.cpp \
+    sub.cpp \
+    tcp.cpp \
+    tcp_address.cpp \
+    tcp_connecter.cpp \
+    tcp_listener.cpp \
+    thread.cpp \
+    trie.cpp \
+    xpub.cpp \
+    router.cpp \
+    dealer.cpp \
+    v1_decoder.cpp \
+    v1_decoder.hpp \
+    v1_encoder.cpp \
+    v1_encoder.hpp \
+    v1_protocol.hpp \
+    xsub.cpp \
+    zmq.cpp \
+    zmq_utils.cpp
+
+if ON_MINGW
+libzmq_la_LDFLAGS = -no-undefined -avoid-version -version-info @LTVER@ @LIBZMQ_EXTRA_LDFLAGS@
+else
+if ON_ANDROID
+libzmq_la_LDFLAGS = -avoid-version -version-info @LTVER@ @LIBZMQ_EXTRA_LDFLAGS@
+else
+libzmq_la_LDFLAGS = -version-info @LTVER@ @LIBZMQ_EXTRA_LDFLAGS@
+endif
+endif
+
+libzmq_la_CXXFLAGS = @LIBZMQ_EXTRA_CXXFLAGS@
+
+if BUILD_PGM
+libzmq_la_CPPFLAGS = -I$(top_srcdir)/@pgm_srcdir@/include/
+libzmq_la_LIBADD = $(top_srcdir)/@pgm_srcdir@/libpgm_noinst.la
+endif
+
+dist-hook:
+		-rm $(distdir)/platform.hpp
+
+

data/ext/zeromq/src/address.cpp

@@ -0,0 +1,78 @@
+/*
+    Copyright (c) 2012 Spotify AB
+    Copyright (c) 2012 Other contributors as noted in the AUTHORS file
+
+    This file is part of 0MQ.
+
+    0MQ is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    0MQ is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "address.hpp"
+#include "err.hpp"
+#include "tcp_address.hpp"
+#include "ipc_address.hpp"
+
+#include <string>
+#include <sstream>
+
+zmq::address_t::address_t (
+    const std::string &protocol_, const std::string &address_)
+    : protocol (protocol_),
+      address (address_)
+{
+    memset (&resolved, 0, sizeof (resolved));
+}
+
+zmq::address_t::~address_t ()
+{
+    if (protocol == "tcp") {
+        if (resolved.tcp_addr) {
+            delete resolved.tcp_addr;
+            resolved.tcp_addr = 0;
+        }
+    }
+#if !defined ZMQ_HAVE_WINDOWS && !defined ZMQ_HAVE_OPENVMS
+    else if (protocol == "ipc") {
+        if (resolved.ipc_addr) {
+            delete resolved.ipc_addr;
+            resolved.ipc_addr = 0;
+        }
+    }
+#endif
+}
+
+int zmq::address_t::to_string (std::string &addr_) const
+{
+    if (protocol == "tcp") {
+        if (resolved.tcp_addr) {
+            return resolved.tcp_addr->to_string(addr_);
+        }
+    }
+#if !defined ZMQ_HAVE_WINDOWS && !defined ZMQ_HAVE_OPENVMS
+    else if (protocol == "ipc") {
+        if (resolved.ipc_addr) {
+            return resolved.ipc_addr->to_string(addr_);
+        }
+    }
+#endif
+
+    if (!protocol.empty () && !address.empty ()) {
+        std::stringstream s;
+        s << protocol << "://" << address;
+        addr_ = s.str ();
+        return 0;
+    }
+    addr_.clear ();
+    return -1;
+}

data/ext/zeromq/src/address.hpp

@@ -0,0 +1,52 @@
+/*
+    Copyright (c) 2012 Spotify AB
+    Copyright (c) 2012 Other contributors as noted in the AUTHORS file
+
+    This file is part of 0MQ.
+
+    0MQ is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    0MQ is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __ZMQ_ADDRESS_HPP_INCLUDED__
+#define __ZMQ_ADDRESS_HPP_INCLUDED__
+
+#include <string>
+
+namespace zmq
+{
+    class tcp_address_t;
+#if !defined ZMQ_HAVE_WINDOWS && !defined ZMQ_HAVE_OPENVMS
+    class ipc_address_t;
+#endif
+    struct address_t {
+        address_t (const std::string &protocol_, const std::string &address_);
+
+        ~address_t ();
+
+        const std::string protocol;
+        const std::string address;
+
+        //  Protocol specific resolved address
+        union {
+            tcp_address_t *tcp_addr;
+#if !defined ZMQ_HAVE_WINDOWS && !defined ZMQ_HAVE_OPENVMS
+            ipc_address_t *ipc_addr;
+#endif
+        } resolved;
+
+        int to_string (std::string &addr_) const;
+    };
+}
+
+#endif

data/ext/zeromq/src/array.hpp

@@ -0,0 +1,155 @@
+/*
+    Copyright (c) 2009-2011 250bpm s.r.o.
+    Copyright (c) 2007-2009 iMatix Corporation
+    Copyright (c) 2007-2011 Other contributors as noted in the AUTHORS file
+
+    This file is part of 0MQ.
+
+    0MQ is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    0MQ is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __ZMQ_ARRAY_INCLUDED__
+#define __ZMQ_ARRAY_INCLUDED__
+
+#include <vector>
+#include <algorithm>
+
+namespace zmq
+{
+
+    //  Base class for objects stored in the array. If you want to store
+    //  same object in mutliple arrays, each of those arrays has to have
+    //  different ID. The item itself has to be derived from instantiations of
+    //  array_item_t template for all relevant IDs.
+
+    template <int ID = 0> class array_item_t
+    {
+    public:
+
+        inline array_item_t () :
+            array_index (-1)
+        {
+        }
+
+        //  The destructor doesn't have to be virtual. It is mad virtual
+        //  just to keep ICC and code checking tools from complaining.
+        inline virtual ~array_item_t ()
+        {
+        }
+
+        inline void set_array_index (int index_)
+        {
+            array_index = index_;
+        }
+
+        inline int get_array_index ()
+        {
+            return array_index;
+        }
+
+    private:
+
+        int array_index;
+
+        array_item_t (const array_item_t&);
+        const array_item_t &operator = (const array_item_t&);
+    };
+
+    //  Fast array implementation with O(1) access to item, insertion and
+    //  removal. Array stores pointers rather than objects. The objects have
+    //  to be derived from array_item_t<ID> class.
+
+    template <typename T, int ID = 0> class array_t
+    {
+    private:
+
+        typedef array_item_t <ID> item_t;
+
+    public:
+
+        typedef typename std::vector <T*>::size_type size_type;
+
+        inline array_t ()
+        {
+        }
+
+        inline ~array_t ()
+        {
+        }
+
+        inline size_type size ()
+        {
+            return items.size ();
+        }
+
+        inline bool empty ()
+        {
+            return items.empty ();
+        }
+
+        inline T *&operator [] (size_type index_)
+        {
+            return items [index_];
+        }
+
+        inline void push_back (T *item_)
+        {
+            if (item_)
+                ((item_t*) item_)->set_array_index ((int) items.size ());
+            items.push_back (item_);
+        }
+
+        inline void erase (T *item_) {
+            erase (((item_t*) item_)->get_array_index ());
+        }
+
+        inline void erase (size_type index_) {
+            if (items.back ())
+                ((item_t*) items.back ())->set_array_index ((int) index_);
+            items [index_] = items.back ();
+            items.pop_back ();
+        }
+
+        inline void swap (size_type index1_, size_type index2_)
+        {
+            if (items [index1_])
+                ((item_t*) items [index1_])->set_array_index ((int) index2_);
+            if (items [index2_])
+                ((item_t*) items [index2_])->set_array_index ((int) index1_);
+            std::swap (items [index1_], items [index2_]);
+        }
+
+        inline void clear ()
+        {
+            items.clear ();
+        }
+
+        inline size_type index (T *item_)
+        {
+            return (size_type) ((item_t*) item_)->get_array_index ();
+        }
+
+    private:
+
+        typedef std::vector <T*> items_t;
+        items_t items;
+
+        array_t (const array_t&);
+        const array_t &operator = (const array_t&);
+    };
+
+}
+
+#endif
+