rbczmq 1.7.1 → 1.7.2

data/ext/zeromq/src/decoder.hpp

@@ -1,7 +1,5 @@
 /*
-    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
+    Copyright (c) 2007-2013 Contributors as noted in the AUTHORS file
 
     This file is part of 0MQ.
 
@@ -34,9 +32,6 @@
 
 namespace zmq
 {
-
-    class i_msg_sink;
-
     //  Helper base class for decoders that know the amount of data to read
     //  in advance at any moment. Knowing the amount in advance is a property
     //  of the protocol used. 0MQ framing protocol is based size-prefixed
@@ -92,106 +87,66 @@ namespace zmq
 
         //  Processes the data in the buffer previously allocated using
         //  get_buffer function. size_ argument specifies nemuber of bytes
-        //  actually filled into the buffer. Function returns number of
-        //  bytes actually processed.
-        inline size_t process_buffer (unsigned char *data_, size_t size_)
+        //  actually filled into the buffer. Function returns 1 when the
+        //  whole message was decoded or 0 when more data is required.
+        //  On error, -1 is returned and errno set accordingly.
+        //  Number of bytes processed is returned in byts_used_.
+        inline int decode (const unsigned char *data_, size_t size_,
+                           size_t &bytes_used_)
         {
-            //  Check if we had an error in previous attempt.
-            if (unlikely (!(static_cast <T*> (this)->next)))
-                return (size_t) -1;
+            bytes_used_ = 0;
 
             //  In case of zero-copy simply adjust the pointers, no copying
             //  is required. Also, run the state machine in case all the data
             //  were processed.
             if (data_ == read_pos) {
+                zmq_assert (size_ <= to_read);
                 read_pos += size_;
                 to_read -= size_;
+                bytes_used_ = size_;
 
                 while (!to_read) {
-                    if (!(static_cast <T*> (this)->*next) ()) {
-                        if (unlikely (!(static_cast <T*> (this)->next)))
-                            return (size_t) -1;
-                        return size_;
-                    }
+                    const int rc = (static_cast <T*> (this)->*next) ();
+                    if (rc != 0)
+                        return rc;
                 }
-                return size_;
+                return 0;
             }
 
-            size_t pos = 0;
-            while (true) {
-
-                //  Try to get more space in the message to fill in.
-                //  If none is available, return.
-                while (!to_read) {
-                    if (!(static_cast <T*> (this)->*next) ()) {
-                        if (unlikely (!(static_cast <T*> (this)->next)))
-                            return (size_t) -1;
-                        return pos;
-                    }
-                }
-
-                //  If there are no more data in the buffer, return.
-                if (pos == size_)
-                    return pos;
-
+            while (bytes_used_ < size_) {
                 //  Copy the data from buffer to the message.
-                size_t to_copy = std::min (to_read, size_ - pos);
-                memcpy (read_pos, data_ + pos, to_copy);
+                const size_t to_copy = std::min (to_read, size_ - bytes_used_);
+                memcpy (read_pos, data_ + bytes_used_, to_copy);
                 read_pos += to_copy;
-                pos += to_copy;
                 to_read -= to_copy;
-            }
-        }
-
-        //  Returns true if the decoder has been fed all required data
-        //  but cannot proceed with the next decoding step.
-        //  False is returned if the decoder has encountered an error.
-        bool stalled ()
-        {
-            //  Check whether there was decoding error.
-            if (unlikely (!(static_cast <T*> (this)->next)))
-                return false;
-
-            while (!to_read) {
-                if (!(static_cast <T*> (this)->*next) ()) {
-                    if (unlikely (!(static_cast <T*> (this)->next)))
-                        return false;
-                    return true;
+                bytes_used_ += to_copy;
+                //  Try to get more space in the message to fill in.
+                //  If none is available, return.
+                while (to_read == 0) {
+                    const int rc = (static_cast <T*> (this)->*next) ();
+                    if (rc != 0)
+                        return rc;
                 }
             }
 
-            return false;
-        }
-
-        inline bool message_ready_size (size_t msg_sz)
-        {
-            zmq_assert (false);
-            return false;
+            return 0;
         }
 
     protected:
 
         //  Prototype of state machine action. Action should return false if
         //  it is unable to push the data to the system.
-        typedef bool (T::*step_t) ();
+        typedef int (T::*step_t) ();
 
         //  This function should be called from derived class to read data
         //  from the buffer and schedule next state machine action.
-        inline void next_step (void *read_pos_, size_t to_read_,
-            step_t next_)
+        inline void next_step (void *read_pos_, size_t to_read_, step_t next_)
         {
             read_pos = (unsigned char*) read_pos_;
             to_read = to_read_;
             next = next_;
         }
 
-        //  This function should be called from the derived class to
-        //  abort decoder state machine.
-        inline void decoding_error ()
-        {
-            next = NULL;
-        }
-
     private:
 
         //  Next step. If set to NULL, it means that associated data stream
@@ -212,36 +167,6 @@ namespace zmq
         decoder_base_t (const decoder_base_t&);
         const decoder_base_t &operator = (const decoder_base_t&);
     };
-
-    //  Decoder for 0MQ framing protocol. Converts data batches into messages.
-
-    class decoder_t : public decoder_base_t <decoder_t>
-    {
-    public:
-
-        decoder_t (size_t bufsize_, int64_t maxmsgsize_);
-        ~decoder_t ();
-
-        //  Set the receiver of decoded messages.
-        void set_msg_sink (i_msg_sink *msg_sink_);
-
-    private:
-
-        bool one_byte_size_ready ();
-        bool eight_byte_size_ready ();
-        bool flags_ready ();
-        bool message_ready ();
-
-        i_msg_sink *msg_sink;
-        unsigned char tmpbuf [8];
-        msg_t in_progress;
-
-        int64_t maxmsgsize;
-
-        decoder_t (const decoder_t&);
-        void operator = (const decoder_t&);
-    };
-
 }
 
 #endif

data/ext/zeromq/src/devpoll.cpp

@@ -1,7 +1,5 @@
 /*
-    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
+    Copyright (c) 2007-2013 Contributors as noted in the AUTHORS file
 
     This file is part of 0MQ.
 

data/ext/zeromq/src/devpoll.hpp

@@ -1,7 +1,5 @@
 /*
-    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
+    Copyright (c) 2007-2013 Contributors as noted in the AUTHORS file
 
     This file is part of 0MQ.
 

data/ext/zeromq/src/dist.cpp

@@ -1,7 +1,5 @@
 /*
-    Copyright (c) 2011 250bpm s.r.o.
-    Copyright (c) 2011 VMware, Inc.
-    Copyright (c) 2011 Other contributors as noted in the AUTHORS file
+    Copyright (c) 2007-2013 Contributors as noted in the AUTHORS file
 
     This file is part of 0MQ.
 
@@ -76,16 +74,23 @@ void zmq::dist_t::unmatch ()
     matching = 0;
 }
 
-void zmq::dist_t::terminated (pipe_t *pipe_)
+void zmq::dist_t::pipe_terminated (pipe_t *pipe_)
 {
     //  Remove the pipe from the list; adjust number of matching, active and/or
     //  eligible pipes accordingly.
-    if (pipes.index (pipe_) < matching)
+    if (pipes.index (pipe_) < matching) {
+        pipes.swap (pipes.index (pipe_), matching - 1);
         matching--;
-    if (pipes.index (pipe_) < active)
+    }
+    if (pipes.index (pipe_) < active) {
+        pipes.swap (pipes.index (pipe_), active - 1);
         active--;
-    if (pipes.index (pipe_) < eligible)
+    }
+    if (pipes.index (pipe_) < eligible) {
+        pipes.swap (pipes.index (pipe_), eligible - 1);
         eligible--;
+    }
+
     pipes.erase (pipe_);
 }
 
@@ -103,19 +108,19 @@ void zmq::dist_t::activated (pipe_t *pipe_)
     }
 }
 
-int zmq::dist_t::send_to_all (msg_t *msg_, int flags_)
+int zmq::dist_t::send_to_all (msg_t *msg_)
 {
     matching = active;
-    return send_to_matching (msg_, flags_);
+    return send_to_matching (msg_);
 }
 
-int zmq::dist_t::send_to_matching (msg_t *msg_, int flags_)
+int zmq::dist_t::send_to_matching (msg_t *msg_)
 {
     //  Is this end of a multipart message?
     bool msg_more = msg_->flags () & msg_t::more ? true : false;
 
     //  Push the message to matching pipes.
-    distribute (msg_, flags_);
+    distribute (msg_);
 
     //  If mutlipart message is fully sent, activate all the eligible pipes.
     if (!msg_more)
@@ -126,11 +131,8 @@ int zmq::dist_t::send_to_matching (msg_t *msg_, int flags_)
     return 0;
 }
 
-void zmq::dist_t::distribute (msg_t *msg_, int flags_)
+void zmq::dist_t::distribute (msg_t *msg_)
 {
-    // flags_ is unused
-    (void)flags_;
-
     //  If there are no matching pipes available, simply drop the message.
     if (matching == 0) {
         int rc = msg_->close ();

data/ext/zeromq/src/dist.hpp

@@ -1,6 +1,5 @@
 /*
-    Copyright (c) 2011 250bpm s.r.o.
-    Copyright (c) 2011 Other contributors as noted in the AUTHORS file
+    Copyright (c) 2007-2013 Contributors as noted in the AUTHORS file
 
     This file is part of 0MQ.
 
@@ -55,13 +54,13 @@ namespace zmq
         void unmatch ();
 
         //  Removes the pipe from the distributor object.
-        void terminated (zmq::pipe_t *pipe_);
+        void pipe_terminated (zmq::pipe_t *pipe_);
 
         //  Send the message to the matching outbound pipes.
-        int send_to_matching (zmq::msg_t *msg_, int flags_);
+        int send_to_matching (zmq::msg_t *msg_);
 
         //  Send the message to all the outbound pipes.
-        int send_to_all (zmq::msg_t *msg_, int flags_);
+        int send_to_all (zmq::msg_t *msg_);
 
         bool has_out ();
 
@@ -72,7 +71,7 @@ namespace zmq
         bool write (zmq::pipe_t *pipe_, zmq::msg_t *msg_);
 
         //  Put the message to all active pipes.
-        void distribute (zmq::msg_t *msg_, int flags_);
+        void distribute (zmq::msg_t *msg_);
 
         //  List of outbound pipes.
         typedef array_t <zmq::pipe_t, 2> pipes_t;

data/ext/zeromq/src/encoder.hpp

@@ -1,7 +1,5 @@
 /*
-    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
+    Copyright (c) 2007-2013 Contributors as noted in the AUTHORS file
 
     This file is part of 0MQ.
 
@@ -40,8 +38,6 @@
 namespace zmq
 {
 
-    class i_msg_source;
-
     //  Helper base class for encoders. It implements the state machine that
     //  fills the outgoing buffer. Derived classes should implement individual
     //  state machine actions.
@@ -51,7 +47,8 @@ namespace zmq
     public:
 
         inline encoder_base_t (size_t bufsize_) :
-            bufsize (bufsize_)
+            bufsize (bufsize_),
+            in_progress (NULL)
         {
             buf = (unsigned char*) malloc (bufsize_);
             alloc_assert (buf);
@@ -67,17 +64,13 @@ namespace zmq
         //  The function returns a batch of binary data. The data
         //  are filled to a supplied buffer. If no buffer is supplied (data_
         //  points to NULL) decoder object will provide buffer of its own.
-        //  If offset is not NULL, it is filled by offset of the first message
-        //  in the batch.If there's no beginning of a message in the batch,
-        //  offset is set to -1.
-        inline void get_data (unsigned char **data_, size_t *size_,
-            int *offset_ = NULL)
+        inline size_t encode (unsigned char **data_, size_t size_)
         {
             unsigned char *buffer = !*data_ ? buf : *data_;
-            size_t buffersize = !*data_ ? bufsize : *size_;
+            size_t buffersize = !*data_ ? bufsize : size_;
 
-            if (offset_)
-                *offset_ = -1;
+            if (in_progress == NULL)
+                return 0;
 
             size_t pos = 0;
             while (pos < buffersize) {
@@ -86,14 +79,15 @@ namespace zmq
                 //  If there are still no data, return what we already have
                 //  in the buffer.
                 if (!to_write) {
-                    //  If we are to encode the beginning of a new message,
-                    //  adjust the message offset.
-                    if (beginning)
-                        if (offset_ && *offset_ == -1)
-                            *offset_ = static_cast <int> (pos);
-
-                    if (!(static_cast <T*> (this)->*next) ())
+                    if (new_msg_flag) {
+                        int rc = in_progress->close ();
+                        errno_assert (rc == 0);
+                        rc = in_progress->init ();
+                        errno_assert (rc == 0);
+                        in_progress = NULL;
                         break;
+                    }
+                    (static_cast <T*> (this)->*next) ();
                 }
 
                 //  If there are no data in the buffer yet and we are able to
@@ -108,10 +102,10 @@ namespace zmq
                 //  amounts of time.
                 if (!pos && !*data_ && to_write >= buffersize) {
                     *data_ = write_pos;
-                    *size_ = to_write;
+                    pos = to_write;
                     write_pos = NULL;
                     to_write = 0;
-                    return;
+                    return pos;
                 }
 
                 //  Copy data to the buffer. If the buffer is full, return.
@@ -123,7 +117,14 @@ namespace zmq
             }
 
             *data_ = buffer;
-            *size_ = pos;
+            return pos;
+        }
+
+        void load_msg (msg_t *msg_)
+        {
+            zmq_assert (in_progress == NULL);
+            in_progress = msg_;
+            (static_cast <T*> (this)->*next) ();
         }
 
         inline bool has_data ()
@@ -134,18 +135,17 @@ namespace zmq
     protected:
 
         //  Prototype of state machine action.
-        typedef bool (T::*step_t) ();
+        typedef void (T::*step_t) ();
 
         //  This function should be called from derived class to write the data
-        //  to the buffer and schedule next state machine action. Set beginning
-        //  to true when you are writing first byte of a message.
+        //  to the buffer and schedule next state machine action.
         inline void next_step (void *write_pos_, size_t to_write_,
-            step_t next_, bool beginning_)
+            step_t next_, bool new_msg_flag_)
         {
             write_pos = (unsigned char*) write_pos_;
             to_write = to_write_;
             next = next_;
-            beginning = beginning_;
+            new_msg_flag = new_msg_flag_;
         }
 
     private:
@@ -160,8 +160,7 @@ namespace zmq
         //  is dead.
         step_t next;
 
-        //  If true, first byte of the message is being written.
-        bool beginning;
+        bool new_msg_flag;
 
         //  The buffer for encoded data.
         size_t bufsize;
@@ -169,30 +168,11 @@ namespace zmq
 
         encoder_base_t (const encoder_base_t&);
         void operator = (const encoder_base_t&);
-    };
 
-    //  Encoder for 0MQ framing protocol. Converts messages into data batches.
-
-    class encoder_t : public encoder_base_t <encoder_t>
-    {
-    public:
-
-        encoder_t (size_t bufsize_);
-        ~encoder_t ();
-
-        void set_msg_source (i_msg_source *msg_source_);
-
-    private:
-
-        bool size_ready ();
-        bool message_ready ();
+    protected:
 
-        i_msg_source *msg_source;
-        msg_t in_progress;
-        unsigned char tmpbuf [10];
+        msg_t *in_progress;
 
-        encoder_t (const encoder_t&);
-        const encoder_t &operator = (const encoder_t&);
     };
 }