summaryrefslogtreecommitdiff
path: root/src/object.hpp
diff options
context:
space:
mode:
authorMicah Anderson <micah@riseup.net>2014-11-11 13:30:46 -0500
committerMicah Anderson <micah@riseup.net>2014-11-11 13:30:46 -0500
commit597cc5edd624525563e6549dc0057eca2a51c81d (patch)
treefc3b8b0ed54e304ea6d0b7da23df1fc67284b339 /src/object.hpp
parent55a5e900b47474528fd6a04ee632164143b05380 (diff)
upgrade to new versiondebian/experimental
Diffstat (limited to 'src/object.hpp')
-rw-r--r--src/object.hpp137
1 files changed, 137 insertions, 0 deletions
diff --git a/src/object.hpp b/src/object.hpp
new file mode 100644
index 0000000..7655c38
--- /dev/null
+++ b/src/object.hpp
@@ -0,0 +1,137 @@
+/*
+ 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_OBJECT_HPP_INCLUDED__
+#define __ZMQ_OBJECT_HPP_INCLUDED__
+
+#include "stdint.hpp"
+
+namespace zmq
+{
+
+ struct i_engine;
+ struct endpoint_t;
+ struct pending_connection_t;
+ struct command_t;
+ class ctx_t;
+ class pipe_t;
+ class socket_base_t;
+ class session_base_t;
+ class io_thread_t;
+ class own_t;
+
+ // Base class for all objects that participate in inter-thread
+ // communication.
+
+ class object_t
+ {
+ public:
+
+ object_t (zmq::ctx_t *ctx_, uint32_t tid_);
+ object_t (object_t *parent_);
+ virtual ~object_t ();
+
+ uint32_t get_tid ();
+ void set_tid(uint32_t id);
+ ctx_t *get_ctx ();
+ void process_command (zmq::command_t &cmd_);
+ void send_inproc_connected (zmq::socket_base_t *socket_);
+ void send_bind (zmq::own_t *destination_, zmq::pipe_t *pipe_, bool inc_seqnum_ = true);
+
+ protected:
+
+ // Using following function, socket is able to access global
+ // repository of inproc endpoints.
+ int register_endpoint (const char *addr_, zmq::endpoint_t &endpoint_);
+ void unregister_endpoints (zmq::socket_base_t *socket_);
+ zmq::endpoint_t find_endpoint (const char *addr_);
+ void pend_connection (const char *addr_, pending_connection_t &pending_connection_);
+ void connect_pending (const char *addr_, zmq::socket_base_t *bind_socket_);
+
+ void destroy_socket (zmq::socket_base_t *socket_);
+
+ // Logs an message.
+ void log (const char *format_, ...);
+
+ // Chooses least loaded I/O thread.
+ zmq::io_thread_t *choose_io_thread (uint64_t affinity_);
+
+ // Derived object can use these functions to send commands
+ // to other objects.
+ void send_stop ();
+ void send_plug (zmq::own_t *destination_,
+ bool inc_seqnum_ = true);
+ void send_own (zmq::own_t *destination_,
+ zmq::own_t *object_);
+ void send_attach (zmq::session_base_t *destination_,
+ zmq::i_engine *engine_, bool inc_seqnum_ = true);
+ void send_activate_read (zmq::pipe_t *destination_);
+ void send_activate_write (zmq::pipe_t *destination_,
+ uint64_t msgs_read_);
+ void send_hiccup (zmq::pipe_t *destination_, void *pipe_);
+ void send_pipe_term (zmq::pipe_t *destination_);
+ void send_pipe_term_ack (zmq::pipe_t *destination_);
+ void send_term_req (zmq::own_t *destination_,
+ zmq::own_t *object_);
+ void send_term (zmq::own_t *destination_, int linger_);
+ void send_term_ack (zmq::own_t *destination_);
+ void send_reap (zmq::socket_base_t *socket_);
+ void send_reaped ();
+ void send_done ();
+
+ // These handlers can be overloaded by the derived objects. They are
+ // called when command arrives from another thread.
+ virtual void process_stop ();
+ virtual void process_plug ();
+ virtual void process_own (zmq::own_t *object_);
+ virtual void process_attach (zmq::i_engine *engine_);
+ virtual void process_bind (zmq::pipe_t *pipe_);
+ virtual void process_activate_read ();
+ virtual void process_activate_write (uint64_t msgs_read_);
+ virtual void process_hiccup (void *pipe_);
+ virtual void process_pipe_term ();
+ virtual void process_pipe_term_ack ();
+ virtual void process_term_req (zmq::own_t *object_);
+ virtual void process_term (int linger_);
+ virtual void process_term_ack ();
+ virtual void process_reap (zmq::socket_base_t *socket_);
+ virtual void process_reaped ();
+
+ // Special handler called after a command that requires a seqnum
+ // was processed. The implementation should catch up with its counter
+ // of processed commands here.
+ virtual void process_seqnum ();
+
+ private:
+
+ // Context provides access to the global state.
+ zmq::ctx_t *ctx;
+
+ // Thread ID of the thread the object belongs to.
+ uint32_t tid;
+
+ void send_command (command_t &cmd_);
+
+ object_t (const object_t&);
+ const object_t &operator = (const object_t&);
+ };
+
+}
+
+#endif