zeromq 0.0.1 → 0.0.2

data/extension/context.c

@@ -67,6 +67,12 @@ void zeromq_context_release( struct zeromq_context* context )
 
 //-----------------------------------------------------------------------------
 
+/*
+ *  Document-class: ZeroMQ::Context
+ *
+ *  The ZeroMQ::Context class ...
+ */ 
+
 VALUE context_declare( VALUE zeromq_module )
 //------------------------------------------
 {
@@ -90,6 +96,11 @@ VALUE context_declare( VALUE zeromq_module )
     return klass;
 }
 
+/*  
+ * @!method default
+ *
+ * The +default+ method ...
+ */
 VALUE context_default( VALUE self )
 //---------------------------------
 {
@@ -134,7 +145,7 @@ static VALUE context_initialize( int arg_count, VALUE* args, VALUE self )
     context->context = zmq_ctx_new();
     if ( !context->context ) 
     {
-        rb_raise( exception_type, "%s", zmq_strerror( zmq_errno() ) );
+        rb_raise( exception_class, "%s", zmq_strerror( zmq_errno() ) );
         return Qnil;
     }
 

data/extension/error.c

@@ -1,3 +1,9 @@
+/*
+ *   Document-class: ZeroMQ::Error
+ *
+ *   The ZeroMQ::Error class ...
+ */
+
 //-----------------------------------------------------------------------------
 
 #include "error.h"

data/extension/extension.c

@@ -6,7 +6,7 @@
 #include "socket.h"
 
 VALUE module;
-VALUE exception_type;
+VALUE exception_class;
 VALUE context_class;
 VALUE socket_class;
 
@@ -15,7 +15,7 @@ void Init_zeromq()
 {
     module = module_declare();
 
-    exception_type = error_declare( module );
+    exception_class = error_declare( module );
     context_class = context_declare( module );
     socket_class = socket_declare( module );
 }

data/extension/extension.h

@@ -60,4 +60,4 @@ typedef unsigned __int64 uint64_t;
 
 extern VALUE context_class;
 extern VALUE socket_class;
-extern VALUE exception_type;
+extern VALUE exception_class;

data/extension/socket.c

@@ -31,6 +31,15 @@ static VALUE socket_send( int argc_, VALUE* argv_, VALUE self_ );
 //-----------------------------------------------------------------------------
 // zeromq socket helper functions
 
+struct zeromq_socket_io_request
+{
+    void*       socket;
+    zmq_msg_t*  message;
+    int         flags;
+
+    int         result;
+};
+
 struct zeromq_socket* zeromq_socket_create()
 //------------------------------------------
 {
@@ -60,6 +69,37 @@ void zeromq_socket_destroy( struct zeromq_socket* zeromq_socket )
     xfree( zeromq_socket );
 }
 
+static VALUE zeromq_socket_send_blocking_region( void* argument )
+//---------------------------------------------------------------
+{
+
+    struct zeromq_socket_io_request* io_request = 
+        ( struct zeromq_socket_io_request* )argument;
+
+    io_request->result = zmq_sendmsg(
+        io_request->socket, 
+        io_request->message, 
+        io_request->flags
+    );
+    
+    return Qnil;
+}
+
+static VALUE zeromq_socket_receive_blocking_region( void* argument )
+//------------------------------------------------------------------
+{
+    struct zeromq_socket_io_request* io_request = 
+        ( struct zeromq_socket_io_request* )argument;
+
+    io_request->result = zmq_recvmsg(
+        io_request->socket, 
+        io_request->message, 
+        io_request->flags
+    );
+    
+    return Qnil;
+}
+
 int zeromq_apply_socket_option( VALUE option, VALUE value, VALUE socket )
 //-----------------------------------------------------------------------
 {
@@ -67,8 +107,18 @@ int zeromq_apply_socket_option( VALUE option, VALUE value, VALUE socket )
     return ST_CONTINUE;
 }
 
-//-----------------------------------------------------------------------------
-// ZeroMQ::Socket class initialization
+/*
+ *   Document-class: ZeroMQ::Socket
+ *
+ *   The Socket class ...
+ */
+
+/* call-seq: new()
+ *
+ * The new method does some stuff.
+ */
+
+//----------------------------------------------------------------------------
 
 VALUE socket_declare( VALUE zeromq_module )
 //-----------------------------------------
@@ -87,6 +137,8 @@ VALUE socket_declare( VALUE zeromq_module )
     rb_define_method( klass, "recv", socket_recv, -1 );
     rb_define_method( klass, "close", socket_close, 0 ); 
 
+    rb_define_alias( klass, "receive", "recv" );
+
     return klass; 
 }
 
@@ -143,7 +195,7 @@ static VALUE socket_initialize( int arg_count, VALUE* arguments, VALUE self )
 
     if ( socket_type == Qnil )
     {
-        rb_raise( exception_type, "The socket type is required." );
+        rb_raise( exception_class, "The socket type is required." );
         return Qnil;        
     }
 
@@ -157,7 +209,7 @@ static VALUE socket_initialize( int arg_count, VALUE* arguments, VALUE self )
     
     if ( !socket->socket ) 
     {
-        rb_raise( exception_type, "%s", zmq_strerror( zmq_errno() ) );
+        rb_raise( exception_class, "%s", zmq_strerror( zmq_errno() ) );
         return Qnil;
     }
 
@@ -180,7 +232,7 @@ static VALUE socket_close( VALUE self_ )
     if (s->socket != NULL) {
         int rc = zmq_close(s->socket);
         if (rc != 0) {
-            rb_raise (exception_type, "%s", zmq_strerror (zmq_errno ()));
+            rb_raise (exception_class, "%s", zmq_strerror (zmq_errno ()));
             return Qnil;
         }
 
@@ -222,7 +274,7 @@ static VALUE socket_getsockopt( VALUE self_, VALUE option_ )
 
             if ( rc != 0 ) 
             {
-                rb_raise (exception_type, "%s", zmq_strerror (zmq_errno ()));
+                rb_raise (exception_class, "%s", zmq_strerror (zmq_errno ()));
                 return Qnil;
             }
 
@@ -247,7 +299,7 @@ static VALUE socket_getsockopt( VALUE self_, VALUE option_ )
 
             if ( rc != 0 ) 
             {
-              rb_raise( exception_type, "%s", zmq_strerror( zmq_errno() ) );
+              rb_raise( exception_class, "%s", zmq_strerror( zmq_errno() ) );
               return Qnil;
             }
 
@@ -280,7 +332,7 @@ static VALUE socket_getsockopt( VALUE self_, VALUE option_ )
 
             if ( rc != 0 ) 
             {
-                rb_raise( exception_type, "%s", zmq_strerror( zmq_errno() ) );
+                rb_raise( exception_class, "%s", zmq_strerror( zmq_errno() ) );
                 return Qnil;
             }
 
@@ -305,7 +357,7 @@ static VALUE socket_getsockopt( VALUE self_, VALUE option_ )
                                  &optvalsize);
 
             if (rc != 0) {
-              rb_raise (exception_type, "%s", zmq_strerror (zmq_errno ()));
+              rb_raise (exception_class, "%s", zmq_strerror (zmq_errno ()));
               return Qnil;
             }
 
@@ -325,7 +377,7 @@ static VALUE socket_getsockopt( VALUE self_, VALUE option_ )
                                  (void *)identity, &optvalsize);
 
             if (rc != 0) {
-              rb_raise (exception_type, "%s", zmq_strerror (zmq_errno ()));
+              rb_raise (exception_class, "%s", zmq_strerror (zmq_errno ()));
               return Qnil;
             }
 
@@ -337,14 +389,15 @@ static VALUE socket_getsockopt( VALUE self_, VALUE option_ )
         break;
         
         default:
-            rb_raise (exception_type, "%s", zmq_strerror (EINVAL));
+            rb_raise (exception_class, "%s", zmq_strerror (EINVAL));
             return Qnil;
     }
   
     return retval;
 }
 
-static VALUE socket_setsockopt (VALUE self_, VALUE option_, VALUE optval_)
+static VALUE socket_setsockopt( VALUE self_, VALUE option_, VALUE optval_ )
+//-------------------------------------------------------------------------
 {
     int rc = 0;
     struct zeromq_socket * s;
@@ -409,14 +462,14 @@ static VALUE socket_setsockopt (VALUE self_, VALUE option_, VALUE optval_)
 
         default:
         {
-            rb_raise( exception_type, "%s", zmq_strerror( EINVAL ) );
+            rb_raise( exception_class, "%s", zmq_strerror( EINVAL ) );
             return Qnil;
         }
     }
 
     if ( rc != 0 ) 
     {
-        rb_raise( exception_type, "%s", zmq_strerror( zmq_errno() ) );
+        rb_raise( exception_class, "%s", zmq_strerror( zmq_errno() ) );
         return Qnil;
     }
 
@@ -424,6 +477,7 @@ static VALUE socket_setsockopt (VALUE self_, VALUE option_, VALUE optval_)
 }
 
 static VALUE socket_bind( VALUE self_, VALUE addr_ )
+//--------------------------------------------------
 {
     struct zeromq_socket * s;
     Data_Get_Struct (self_, struct zeromq_socket, s);
@@ -431,7 +485,7 @@ static VALUE socket_bind( VALUE self_, VALUE addr_ )
 
     int rc = zmq_bind (s->socket, rb_string_value_cstr (&addr_));
     if (rc != 0) {
-        rb_raise (exception_type, "%s", zmq_strerror (zmq_errno ()));
+        rb_raise (exception_class, "%s", zmq_strerror (zmq_errno ()));
         return Qnil;
     }
 
@@ -439,6 +493,7 @@ static VALUE socket_bind( VALUE self_, VALUE addr_ )
 }
 
 static VALUE socket_connect( VALUE self_, VALUE addr_ )
+//-----------------------------------------------------
 {
     struct zeromq_socket * s;
     Data_Get_Struct (self_, struct zeromq_socket, s);
@@ -446,146 +501,156 @@ static VALUE socket_connect( VALUE self_, VALUE addr_ )
 
     int rc = zmq_connect (s->socket, rb_string_value_cstr (&addr_));
     if (rc != 0) {
-        rb_raise (exception_type, "%s", zmq_strerror (zmq_errno ()));
+        rb_raise (exception_class, "%s", zmq_strerror (zmq_errno ()));
         return Qnil;
     }
 
     return Qnil;
 }
 
-#ifdef HAVE_RUBY_INTERN_H
-struct zmq_send_recv_args {
-    void *socket;
-    zmq_msg_t *msg;
-    int flags;
-    int rc;
-};
-
-static VALUE zmq_send_blocking( void* args_ )
+static VALUE socket_send( int argument_count, VALUE* arguments, VALUE self )
+//--------------------------------------------------------------------------
 {
-    struct zmq_send_recv_args *send_args = (struct zmq_send_recv_args *)args_;
-
-    send_args->rc = zmq_sendmsg(
-        send_args->socket, 
-        send_args->msg, 
-        send_args->flags
-    );
+    VALUE message_bytes_value, flags_value;
     
-    return Qnil;
-}
-#endif
-
-static VALUE socket_send (int argc_, VALUE* argv_, VALUE self_)
-{
-    VALUE msg_, flags_;
-    
-    rb_scan_args (argc_, argv_, "11", &msg_, &flags_);
-
-    struct zeromq_socket * s;
-    Data_Get_Struct (self_, struct zeromq_socket, s);
-    Check_Socket (s);
+    rb_scan_args( 
+        argument_count, 
+        arguments, 
+        "11", 
+        &message_bytes_value, 
+        &flags_value 
+    );
 
-    Check_Type (msg_, T_STRING);
+    Check_Type( message_bytes_value, T_STRING );
+    int flags = NIL_P( flags_value ) ? 0 : NUM2INT( flags_value );
 
-    int flags = NIL_P (flags_) ? 0 : NUM2INT (flags_);
+    struct zeromq_socket* socket;
+    Data_Get_Struct( self, struct zeromq_socket, socket );
+    Check_Socket( socket );
 
-    zmq_msg_t msg;
-    int msg_len = (int)RSTRING_LEN (msg_);
-    int rc = zmq_msg_init_size (&msg, msg_len);
-    if (rc != 0) {
-        rb_raise (exception_type, "%s", zmq_strerror (zmq_errno ()));
+    zmq_msg_t   message;
+    int         message_length = ( int )RSTRING_LEN( message_bytes_value );
+    
+    int result = zmq_msg_init_size( &message, message_length );
+    if ( result != 0 ) 
+    {
+        rb_raise( exception_class, "%s", zmq_strerror( zmq_errno() ) );
         return Qnil;
     }
-    memcpy (zmq_msg_data (&msg), RSTRING_PTR (msg_), msg_len);
-
-#ifdef HAVE_RUBY_INTERN_H
-    if (!(flags & ZMQ_NOBLOCK)) {
-        struct zmq_send_recv_args send_args;
-        send_args.socket = s->socket;
-        send_args.msg = &msg;
-        send_args.flags = flags;
-        rb_thread_blocking_region (zmq_send_blocking, (void*) &send_args, NULL, NULL);
-        rc = send_args.rc;
+
+    memcpy( 
+        zmq_msg_data( &message ), 
+        RSTRING_PTR( message_bytes_value ), 
+        message_length 
+    );
+
+    if ( !( flags & ZMQ_NOBLOCK ) ) 
+    {
+        struct zeromq_socket_io_request io_request;
+        io_request.socket   =   socket->socket;
+        io_request.message  =   &message;
+        io_request.flags    =   flags;
+
+        rb_thread_blocking_region(
+            zeromq_socket_send_blocking_region, 
+            ( void* )&io_request, 
+            NULL, 
+            NULL
+        );
+        
+        result = io_request.result;
     }
     else
-#endif
-        rc = zmq_sendmsg( s->socket, &msg, flags );
-    if (rc != 0 && zmq_errno () == EAGAIN) {
-        rc = zmq_msg_close (&msg);
-        assert (rc == 0);
+    {
+        result = zmq_sendmsg( socket->socket, &message, flags );
+    }
+
+    if ( result == -1 && zmq_errno() == EAGAIN ) 
+    {
+        result = zmq_msg_close( &message );
+        assert( result == 0 );
         return Qfalse;
     }
 
-    if (rc != 0) {
-        rb_raise (exception_type, "%s", zmq_strerror (zmq_errno ()));
-        rc = zmq_msg_close (&msg);
-        assert (rc == 0);
+    if ( result == -1 ) 
+    {
+        rb_raise( exception_class, "%s", zmq_strerror( zmq_errno() ) );
+
+        result = zmq_msg_close( &message );
+        assert( result == 0 );
+
         return Qnil;
     }
 
-    rc = zmq_msg_close (&msg);
-    assert (rc == 0);
+    result = zmq_msg_close( &message );
+    assert( result == 0 );
+
     return Qtrue;
 }
 
-#ifdef HAVE_RUBY_INTERN_H
-static VALUE zmq_recv_blocking (void* args_)
+static VALUE socket_recv( int argument_count, VALUE* arguments, VALUE self )
+//--------------------------------------------------------------------------
 {
-    struct zmq_send_recv_args *recv_args = (struct zmq_send_recv_args *)args_;
-
-    recv_args->rc = zmq_recvmsg(recv_args->socket, recv_args->msg, recv_args->flags);
+    VALUE flags_value;
     
-    return Qnil;
-}
-#endif
+    rb_scan_args( 
+        argument_count, 
+        arguments, 
+        "01", 
+        &flags_value 
+    );
 
-static VALUE socket_recv (int argc_, VALUE* argv_, VALUE self_)
-{
-    VALUE flags_;
-    
-    rb_scan_args (argc_, argv_, "01", &flags_);
+    int flags = NIL_P( flags_value ) ? 0 : NUM2INT( flags_value );
 
-    struct zeromq_socket * s;
-    Data_Get_Struct (self_, struct zeromq_socket, s);
-    Check_Socket (s);
+    struct zeromq_socket* socket;
+    Data_Get_Struct( self, struct zeromq_socket, socket );
+    Check_Socket( socket ); 
 
-    int flags = NIL_P (flags_) ? 0 : NUM2INT (flags_);
-
-    zmq_msg_t msg;
-    int rc = zmq_msg_init (&msg);
-    assert (rc == 0);
-
-#ifdef HAVE_RUBY_INTERN_H
-    if (!(flags & ZMQ_NOBLOCK)) {
-        struct zmq_send_recv_args recv_args;
-        recv_args.socket = s->socket;
-        recv_args.msg = &msg;
-        recv_args.flags = flags;
-        rb_thread_blocking_region (zmq_recv_blocking, (void*) &recv_args,
-            NULL, NULL);
-        rc = recv_args.rc;
+    zmq_msg_t message;
+    int rc = zmq_msg_init( &message );
+    assert( rc == 0 );
+
+    if ( !( flags & ZMQ_NOBLOCK ) ) 
+    {
+        struct zeromq_socket_io_request io_request;
+        io_request.socket   =   socket->socket;
+        io_request.message  =   &message;
+        io_request.flags    =   flags;
+
+        rb_thread_blocking_region(
+            zeromq_socket_receive_blocking_region, 
+            ( void* )&io_request, 
+            NULL, 
+            NULL
+        );
     }
     else
-#endif
-        rc = zmq_recvmsg(s->socket, &msg, flags);
-    if (rc == -1 && zmq_errno () == EAGAIN) {
-        rc = zmq_msg_close (&msg);
-        assert (rc == 0);
-        return Qnil;
+    {
+        rc = zmq_recvmsg( socket->socket, &message, flags );
     }
 
-    if (rc == -1) {
-        rb_raise (exception_type, "%s", zmq_strerror (zmq_errno ()));
-        rc = zmq_msg_close (&msg);
-        assert (rc == 0);
+    if ( rc == -1 && zmq_errno() == EAGAIN ) 
+    {
+        rc = zmq_msg_close( &message );
+        assert( rc == 0 );
         return Qnil;
     }
 
-    VALUE message = rb_str_new ((char*) zmq_msg_data (&msg),
-        zmq_msg_size (&msg));
-    rc = zmq_msg_close (&msg);
-    assert (rc == 0);
-    return message;
-}
+    if ( rc == -1 ) 
+    {
+        rb_raise( exception_class, "%s", zmq_strerror( zmq_errno() ) );
+        rc = zmq_msg_close( &message );
+        assert( rc == 0 );
+        return Qnil;
+    }
 
+    VALUE message_bytes_value = rb_str_new( 
+        ( char* )zmq_msg_data( &message ),
+        zmq_msg_size( &message ) 
+    );
+    
+    rc = zmq_msg_close( &message );
+    assert( rc == 0 );
 
+    return message_bytes_value;
+}

data/extension/zeromq.c

@@ -219,7 +219,7 @@ static VALUE internal_select(VALUE argval)
         rc = zmq_poll (ps.items, ps.nitems, arg->timeout_usec);
     
     if (rc == -1) {
-        rb_raise(exception_type, "%s", zmq_strerror (zmq_errno ()));
+        rb_raise(exception_class, "%s", zmq_strerror (zmq_errno ()));
         return Qnil;
     }
     else if (rc == 0)

data/lib/zeromq/version.rb

@@ -1,3 +1,3 @@
 module ZeroMQ
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zeromq
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -51,7 +51,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Ruby API for ZeroMQ