From c79abee6bcaa996f50be71bd1d3075e3affb469d Mon Sep 17 00:00:00 2001 From: AJ Lewis Date: Wed, 9 Nov 2011 15:22:20 +0100 Subject: Get AIX 6.1 compiling again by making msg_t class explicit Older versions of gcc have problems with in-line forward declarations when there's a naming conflict with a global symbol. Signed-off-by: AJ Lewis Expand the original patch to all such forward declarations. Signed-off-by: Martin Sustrik --- src/object.hpp | 69 ++++++++++++++++++++++++++++++++++------------------------ 1 file changed, 40 insertions(+), 29 deletions(-) (limited to 'src/object.hpp') diff --git a/src/object.hpp b/src/object.hpp index f832596..932cea7 100644 --- a/src/object.hpp +++ b/src/object.hpp @@ -26,6 +26,17 @@ namespace zmq { + + struct i_engine; + struct endpoint_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. @@ -33,51 +44,51 @@ namespace zmq { public: - object_t (class ctx_t *ctx_, uint32_t tid_); + object_t (zmq::ctx_t *ctx_, uint32_t tid_); object_t (object_t *parent_); virtual ~object_t (); uint32_t get_tid (); ctx_t *get_ctx (); - void process_command (struct command_t &cmd_); + void process_command (zmq::command_t &cmd_); protected: // Using following function, socket is able to access global // repository of inproc endpoints. - int register_endpoint (const char *addr_, struct endpoint_t &endpoint_); - void unregister_endpoints (class socket_base_t *socket_); - struct endpoint_t find_endpoint (const char *addr_); - void destroy_socket (class socket_base_t *socket_); + 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 destroy_socket (zmq::socket_base_t *socket_); // Logs an message. void log (const char *format_, ...); // Chooses least loaded I/O thread. - class io_thread_t *choose_io_thread (uint64_t affinity_); + 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 (class own_t *destination_, + void send_plug (zmq::own_t *destination_, bool inc_seqnum_ = true); - void send_own (class own_t *destination_, - class own_t *object_); - void send_attach (class session_base_t *destination_, - struct i_engine *engine_, bool inc_seqnum_ = true); - void send_bind (class own_t *destination_, class pipe_t *pipe_, + 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_bind (zmq::own_t *destination_, zmq::pipe_t *pipe_, bool inc_seqnum_ = true); - void send_activate_read (class pipe_t *destination_); - void send_activate_write (class pipe_t *destination_, + void send_activate_read (zmq::pipe_t *destination_); + void send_activate_write (zmq::pipe_t *destination_, uint64_t msgs_read_); - void send_hiccup (class pipe_t *destination_, void *pipe_); - void send_pipe_term (class pipe_t *destination_); - void send_pipe_term_ack (class pipe_t *destination_); - void send_term_req (class own_t *destination_, - class own_t *object_); - void send_term (class own_t *destination_, int linger_); - void send_term_ack (class own_t *destination_); - void send_reap (class socket_base_t *socket_); + 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 (); @@ -85,18 +96,18 @@ namespace zmq // called when command arrives from another thread. virtual void process_stop (); virtual void process_plug (); - virtual void process_own (class own_t *object_); - virtual void process_attach (struct i_engine *engine_); - virtual void process_bind (class pipe_t *pipe_); + 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 (class own_t *object_); + virtual void process_term_req (zmq::own_t *object_); virtual void process_term (int linger_); virtual void process_term_ack (); - virtual void process_reap (class socket_base_t *socket_); + virtual void process_reap (zmq::socket_base_t *socket_); virtual void process_reaped (); // Special handler called after a command that requires a seqnum @@ -107,7 +118,7 @@ namespace zmq private: // Context provides access to the global state. - class ctx_t *ctx; + zmq::ctx_t *ctx; // Thread ID of the thread the object belongs to. uint32_t tid; -- cgit v1.2.3