1 files changed, 40 insertions, 29 deletions

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;