From 597cc5edd624525563e6549dc0057eca2a51c81d Mon Sep 17 00:00:00 2001
From: Micah Anderson <micah@riseup.net>
Date: Tue, 11 Nov 2014 13:30:46 -0500
Subject: upgrade to new version

---
 src/command.hpp | 153 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 153 insertions(+)
 create mode 100644 src/command.hpp

(limited to 'src/command.hpp')

diff --git a/src/command.hpp b/src/command.hpp
new file mode 100644
index 0000000..fc0181b
--- /dev/null
+++ b/src/command.hpp
@@ -0,0 +1,153 @@
+/*
+    Copyright (c) 2007-2013 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_COMMAND_HPP_INCLUDED__
+#define __ZMQ_COMMAND_HPP_INCLUDED__
+
+#include "stdint.hpp"
+
+namespace zmq
+{
+
+    class object_t;
+    class own_t;
+    struct i_engine;
+    class pipe_t;
+    class socket_base_t;
+
+    //  This structure defines the commands that can be sent between threads.
+
+    struct command_t
+    {
+        //  Object to process the command.
+        zmq::object_t *destination;
+
+        enum type_t
+        {
+            stop,
+            plug,
+            own,
+            attach,
+            bind,
+            activate_read,
+            activate_write,
+            hiccup,
+            pipe_term,
+            pipe_term_ack,
+            term_req,
+            term,
+            term_ack,
+            reap,
+            reaped,
+            inproc_connected,
+            done
+        } type;
+
+        union {
+
+            //  Sent to I/O thread to let it know that it should
+            //  terminate itself.
+            struct {
+            } stop;
+
+            //  Sent to I/O object to make it register with its I/O thread.
+            struct {
+            } plug;
+
+            //  Sent to socket to let it know about the newly created object.
+            struct {
+                zmq::own_t *object;
+            } own;
+
+            //  Attach the engine to the session. If engine is NULL, it informs
+            //  session that the connection have failed.
+            struct {
+                struct i_engine *engine;
+            } attach;
+
+            //  Sent from session to socket to establish pipe(s) between them.
+            //  Caller have used inc_seqnum beforehand sending the command.
+            struct {
+                zmq::pipe_t *pipe;
+            } bind;
+
+            //  Sent by pipe writer to inform dormant pipe reader that there
+            //  are messages in the pipe.
+            struct {
+            } activate_read;
+
+            //  Sent by pipe reader to inform pipe writer about how many
+            //  messages it has read so far.
+            struct {
+                uint64_t msgs_read;
+            } activate_write;
+
+            //  Sent by pipe reader to writer after creating a new inpipe.
+            //  The parameter is actually of type pipe_t::upipe_t, however,
+            //  its definition is private so we'll have to do with void*.
+            struct {
+                void *pipe;
+            } hiccup;
+
+            //  Sent by pipe reader to pipe writer to ask it to terminate
+            //  its end of the pipe.
+            struct {
+            } pipe_term;
+
+            //  Pipe writer acknowledges pipe_term command.
+            struct {
+            } pipe_term_ack;
+
+            //  Sent by I/O object ot the socket to request the shutdown of
+            //  the I/O object.
+            struct {
+                zmq::own_t *object;
+            } term_req;
+
+            //  Sent by socket to I/O object to start its shutdown.
+            struct {
+                int linger;
+            } term;
+
+            //  Sent by I/O object to the socket to acknowledge it has
+            //  shut down.
+            struct {
+            } term_ack;
+
+            //  Transfers the ownership of the closed socket
+            //  to the reaper thread.
+            struct {
+                zmq::socket_base_t *socket;
+            } reap;
+
+            //  Closed socket notifies the reaper that it's already deallocated.
+            struct {
+            } reaped;
+
+            //  Sent by reaper thread to the term thread when all the sockets
+            //  are successfully deallocated.
+            struct {
+            } done;
+
+        } args;
+    };
+
+}    
+
+#endif
-- 
cgit v1.2.3