r2corba 1.5.2 → 1.6.0

data/ext/libr2tao/orb.cpp

@@ -20,7 +20,7 @@
 #include "ace/Reactor.h"
 #include "ace/Signal.h"
 #include "ace/Sig_Handler.h"
-#include "ace/Auto_Ptr.h"
+#include <memory>
 
 #define RUBY_INVOKE_FUNC RUBY_ALLOC_FUNC
 
@@ -61,8 +61,8 @@ public:
   virtual ~R2CSigGuard();
 
   virtual int handle_signal (int signum,
-                             siginfo_t * = 0,
-                             ucontext_t * = 0);
+                             siginfo_t * = nullptr,
+                             ucontext_t * = nullptr);
 
   bool has_caught_signal () { return this->m_signal_caught; }
 
@@ -71,9 +71,9 @@ private:
   {
   public:
     Signal(int signum) : m_signum (signum) {}
-    virtual ~Signal() {}
+    ~Signal() override = default;
 
-    virtual int handle_exception (ACE_HANDLE fd = ACE_INVALID_HANDLE);
+    int handle_exception (ACE_HANDLE fd = ACE_INVALID_HANDLE) override;
 
   private:
     int inner_handler ();
@@ -85,7 +85,7 @@ private:
 
   static VALUE c_signums;
   static int c_nsig;
-  static ACE_Auto_Ptr<ACE_SIGACTION>  c_sa;
+  static ACE_Auto_Ptr<ACE_SIGACTION> c_sa;
 
   static void init_ ();
 
@@ -103,7 +103,7 @@ public:
 };
 
 #if defined (WIN32)
-R2CSigGuard* R2CSigGuard::c_sig_guard = 0;
+R2CSigGuard* R2CSigGuard::c_sig_guard = nullptr;
 
 BOOL WINAPI CtrlHandlerRoutine (DWORD /*dwCtrlType*/)
 {
@@ -124,11 +124,8 @@ _orb_free(void *ptr)
 R2TAO_EXPORT VALUE
 r2tao_ORB_t2r(CORBA::ORB_ptr obj)
 {
-  VALUE ret;
-  CORBA::ORB_ptr _orb;
-
-  _orb = CORBA::ORB::_duplicate(obj);
-  ret = Data_Wrap_Struct(r2tao_cORB, 0, _orb_free, _orb);
+  CORBA::ORB_ptr _orb = CORBA::ORB::_duplicate(obj);
+  VALUE ret = Data_Wrap_Struct(r2tao_cORB, 0, _orb_free, _orb);
 
   return ret;
 }
@@ -222,11 +219,9 @@ VALUE r2tao_ORB_hash(VALUE self)
 static
 VALUE r2tao_ORB_eql(VALUE self, VALUE _other)
 {
-  CORBA::ORB_ptr other, obj;
-
-  obj = r2tao_ORB_r2t (self);
+  CORBA::ORB_ptr obj = r2tao_ORB_r2t (self);
   r2tao_check_type (_other, r2tao_cORB);
-  other = r2tao_ORB_r2t (_other);
+  CORBA::ORB_ptr other = r2tao_ORB_r2t (_other);
 
   if (obj == other)
     return Qtrue;
@@ -242,7 +237,7 @@ VALUE rCORBA_ORB_init(int _argc, VALUE *_argv, VALUE /*klass*/) {
   char **argv;
   int i;
   CORBA::ORB_var orb;
-  ACE_Auto_Basic_Ptr<char*> argv_safe;
+  std::unique_ptr<char*> argv_safe;
 
   rb_scan_args(_argc, _argv, "02", &v0, &v1);
 
@@ -306,12 +301,10 @@ VALUE rCORBA_ORB_init(int _argc, VALUE *_argv, VALUE /*klass*/) {
 static
 VALUE rCORBA_ORB_object_to_string(VALUE self, VALUE _obj)
 {
-  CORBA::Object_ptr obj;
-  char *str=0;
-  CORBA::ORB_ptr orb;
+  char *str = nullptr;
 
-  orb = r2tao_ORB_r2t (self);
-  obj = r2tao_Object_r2t (_obj);
+  CORBA::ORB_ptr orb = r2tao_ORB_r2t (self);
+  CORBA::Object_ptr obj = r2tao_Object_r2t (_obj);
 
   if (obj->_is_local ())
   {
@@ -331,10 +324,9 @@ static
 VALUE rCORBA_ORB_string_to_object(VALUE self, VALUE _str)
 {
   CORBA::Object_var obj;
-  char *str=0;
-  CORBA::ORB_ptr orb;
+  char *str = nullptr;
 
-  orb = r2tao_ORB_r2t (self);
+  CORBA::ORB_ptr orb = r2tao_ORB_r2t (self);
   Check_Type(_str, T_STRING);
   str = RSTRING_PTR (_str);
 
@@ -364,12 +356,8 @@ VALUE rCORBA_ORB_get_current(VALUE /*self*/)
 static
 VALUE rCORBA_ORB_list_initial_services(VALUE self)
 {
-  CORBA::ULong i;
-  VALUE ary;
   CORBA::ORB::ObjectIdList_var list;
-  CORBA::ORB_ptr orb;
-
-  orb = r2tao_ORB_r2t (self);
+  CORBA::ORB_ptr orb = r2tao_ORB_r2t (self);
 
   R2TAO_TRY
   {
@@ -377,8 +365,8 @@ VALUE rCORBA_ORB_list_initial_services(VALUE self)
   }
   R2TAO_CATCH;
 
-  ary = rb_ary_new2(list->length ());
-  for (i=0; i<list->length (); i++)
+  VALUE ary = rb_ary_new2(list->length ());
+  for (CORBA::ULong i = 0; i < list->length (); i++)
   {
     char const * id = list[i];
     rb_ary_push (ary, rb_str_new2 (id));
@@ -391,13 +379,10 @@ static
 VALUE rCORBA_ORB_resolve_initial_references(VALUE self, VALUE _id)
 {
   CORBA::Object_var obj;
-  char *id;
-  CORBA::ORB_ptr orb;
-
-  orb = r2tao_ORB_r2t (self);
+  CORBA::ORB_ptr orb = r2tao_ORB_r2t (self);
 
   Check_Type(_id, T_STRING);
-  id = RSTRING_PTR (_id);
+  char *id = RSTRING_PTR (_id);
 
   R2TAO_TRY
   {
@@ -418,15 +403,11 @@ VALUE rCORBA_ORB_resolve_initial_references(VALUE self, VALUE _id)
 static
 VALUE rCORBA_ORB_register_initial_reference(VALUE self, VALUE _id, VALUE _obj)
 {
-  CORBA::Object_var obj;
-  char *id;
-  CORBA::ORB_ptr orb;
-
-  orb = r2tao_ORB_r2t (self);
+  CORBA::ORB_ptr orb = r2tao_ORB_r2t (self);
 
   Check_Type(_id, T_STRING);
-  id = RSTRING_PTR (_id);
-  obj = r2tao_Object_r2t(_obj);
+  char *id = RSTRING_PTR (_id);
+  CORBA::Object_var obj = r2tao_Object_r2t(_obj);
 
   R2TAO_TRY
   {
@@ -448,16 +429,11 @@ class R2TAO_ORB_BlockedRegionCaller
 {
 public:
   R2TAO_ORB_BlockedRegionCaller (CORBA::ORB_ptr orb)
-    : orb_ (orb),
-      timeout_ (0),
-      exception_ (false),
-      corba_ex_ (0) {}
+    : orb_ (orb) {}
   R2TAO_ORB_BlockedRegionCaller (CORBA::ORB_ptr orb, ACE_Time_Value& to)
     : orb_ (orb),
-      timeout_ (&to),
-      exception_ (false),
-      corba_ex_ (0) {}
-  virtual ~R2TAO_ORB_BlockedRegionCaller () R2CORBA_NO_EXCEPT_FALSE;
+      timeout_ (std::addressof(to)) {}
+  virtual ~R2TAO_ORB_BlockedRegionCaller () noexcept(false);
 
   VALUE call (bool with_unblock=true);
 
@@ -472,18 +448,18 @@ protected:
   virtual VALUE do_exec () = 0;
 
   CORBA::ORB_ptr orb_;
-  ACE_Time_Value* timeout_;
-  bool exception_;
-  CORBA::Exception* corba_ex_;
+  ACE_Time_Value* timeout_ {};
+  bool exception_ {};
+  CORBA::Exception* corba_ex_ {};
 };
 
-R2TAO_ORB_BlockedRegionCaller::~R2TAO_ORB_BlockedRegionCaller() R2CORBA_NO_EXCEPT_FALSE
+R2TAO_ORB_BlockedRegionCaller::~R2TAO_ORB_BlockedRegionCaller() noexcept(false)
 {
   if (this->exception_)
   {
     if (corba_ex_)
     {
-      ACE_Auto_Basic_Ptr<CORBA::Exception> e_ptr(corba_ex_);
+      std::unique_ptr<CORBA::Exception> e_ptr(corba_ex_);
       corba_ex_->_raise ();
     }
     else
@@ -546,10 +522,10 @@ public:
     : R2TAO_ORB_BlockedRegionCaller (orb) {}
   R2TAO_ORB_BlockedRun (CORBA::ORB_ptr orb, ACE_Time_Value& to)
     : R2TAO_ORB_BlockedRegionCaller (orb, to) {}
-  virtual ~R2TAO_ORB_BlockedRun () {}
+  ~R2TAO_ORB_BlockedRun () override = default;
 
 protected:
-  virtual VALUE do_exec ();
+  VALUE do_exec () override;
 };
 
 VALUE R2TAO_ORB_BlockedRun::do_exec ()
@@ -568,16 +544,16 @@ public:
     : R2TAO_ORB_BlockedRegionCaller (orb), sg_(sg) {}
   R2TAO_ORB_BlockedWorkPending (R2CSigGuard& sg, CORBA::ORB_ptr orb, ACE_Time_Value& to)
     : R2TAO_ORB_BlockedRegionCaller (orb, to), sg_(sg) {}
-  virtual ~R2TAO_ORB_BlockedWorkPending () R2CORBA_NO_EXCEPT_FALSE;
+  virtual ~R2TAO_ORB_BlockedWorkPending () noexcept(false);
 
 protected:
-  virtual VALUE do_exec ();
+  VALUE do_exec () override;
 
 private:
   R2CSigGuard& sg_;
 };
 
-R2TAO_ORB_BlockedWorkPending::~R2TAO_ORB_BlockedWorkPending() R2CORBA_NO_EXCEPT_FALSE
+R2TAO_ORB_BlockedWorkPending::~R2TAO_ORB_BlockedWorkPending() noexcept(false)
 {
   if (this->exception_)
   {
@@ -585,7 +561,7 @@ R2TAO_ORB_BlockedWorkPending::~R2TAO_ORB_BlockedWorkPending() R2CORBA_NO_EXCEPT_
     try {
       if (corba_ex_)
       {
-        ACE_Auto_Basic_Ptr<CORBA::Exception> e_ptr(corba_ex_);
+        std::unique_ptr<CORBA::Exception> e_ptr(corba_ex_);
         corba_ex_->_raise ();
       }
       else
@@ -623,10 +599,10 @@ public:
     : R2TAO_ORB_BlockedRegionCaller (orb) {}
   R2TAO_ORB_BlockedPerformWork (CORBA::ORB_ptr orb, ACE_Time_Value& to)
     : R2TAO_ORB_BlockedRegionCaller (orb, to) {}
-  virtual ~R2TAO_ORB_BlockedPerformWork () {}
+  ~R2TAO_ORB_BlockedPerformWork () override = default;
 
 protected:
-  virtual VALUE do_exec ();
+  VALUE do_exec () override;
 };
 
 VALUE R2TAO_ORB_BlockedPerformWork::do_exec ()
@@ -641,10 +617,10 @@ VALUE R2TAO_ORB_BlockedPerformWork::do_exec ()
 class R2TAO_ORB_BlockedShutdown : public R2TAO_ORB_BlockedRegionCaller
 {
 public:
-  R2TAO_ORB_BlockedShutdown (CORBA::ORB_ptr orb, bool wait=false)
+  R2TAO_ORB_BlockedShutdown (CORBA::ORB_ptr orb, bool wait = false)
     : R2TAO_ORB_BlockedRegionCaller (orb),
       wait_ (wait) {}
-  virtual ~R2TAO_ORB_BlockedShutdown () {}
+  ~R2TAO_ORB_BlockedShutdown () override = default;
 
 protected:
   virtual VALUE do_exec ();
@@ -662,7 +638,6 @@ VALUE R2TAO_ORB_BlockedShutdown::do_exec ()
 static
 VALUE rCORBA_ORB_run(int _argc, VALUE *_argv, VALUE self)
 {
-  CORBA::ORB_ptr orb;
   VALUE rtimeout = Qnil;
   ACE_Time_Value timeout;
   double tmleft=0.0;
@@ -682,7 +657,7 @@ VALUE rCORBA_ORB_run(int _argc, VALUE *_argv, VALUE self)
     // convert to ACE_Time_Value
   }
 
-  orb = r2tao_ORB_r2t (self);
+  CORBA::ORB_ptr orb = r2tao_ORB_r2t (self);
 
   R2TAO_TRY
   {
@@ -715,7 +690,6 @@ VALUE rCORBA_ORB_run(int _argc, VALUE *_argv, VALUE self)
 static
 VALUE rCORBA_ORB_work_pending(int _argc, VALUE *_argv, VALUE self)
 {
-  CORBA::ORB_ptr orb;
   VALUE rtimeout = Qnil;
   ACE_Time_Value timeout;
   double tmleft=0.0;
@@ -735,7 +709,7 @@ VALUE rCORBA_ORB_work_pending(int _argc, VALUE *_argv, VALUE self)
     // convert to ACE_Time_Value
   }
 
-  orb = r2tao_ORB_r2t (self);
+  CORBA::ORB_ptr orb = r2tao_ORB_r2t (self);
 
   VALUE _rc = Qfalse;
 
@@ -858,8 +832,7 @@ VALUE rCORBA_ORB_shutdown(int _argc, VALUE *_argv, VALUE self)
 static
 VALUE rCORBA_ORB_destroy(VALUE self)
 {
-  CORBA::ORB_ptr orb;
-  orb = r2tao_ORB_r2t (self);
+  CORBA::ORB_ptr orb = r2tao_ORB_r2t (self);
   R2TAO_TRY
   {
     orb->destroy ();

data/ext/libr2tao/r2tao_export.h

@@ -1,6 +1,6 @@
 // -*- C++ -*-
 /*--------------------------------------------------------------------
-# r2tao_ext.h - R2TAO CORBA basic support
+# r2tao_export.h - R2TAO CORBA basic support
 #
 # Author: Martin Corino
 #

data/ext/libr2tao/r2tao_ext.h

@@ -12,25 +12,14 @@
 #ifndef __R2TAO_EXT_H
 #define __R2TAO_EXT_H
 
-#if defined (__cplusplus)
-};
-#endif
-
-#if defined (OLD_MSC_VER)
-  // un-fudge the version macro here that was fudged
-  // in required.h otherwise ACE will complain
-  #undef _MSC_VER
-  #define _MSC_VER OLD_MSC_VER
-#endif
-
-#include <ace/pre.h>
-
-#include <ace/config-all.h>
-
-#include <ace/post.h>
-
-#if defined (__cplusplus)
-extern "C" {
+#include <ace/config-lite.h>
+#if defined (WIN32) || defined (_MSC_VER) || defined (__MINGW32__)
+// Ruby ships its own msghdr
+# undef ACE_LACKS_MSGHDR
+// Ruby ships its own iovec
+# undef ACE_LACKS_IOVEC
+// Resolve conflict between mingw and ruby gettimeofday
+# define ACE_LACKS_SYS_TIME_H
 #endif
 
 #endif

data/ext/libr2tao/required.cpp

@@ -17,10 +17,10 @@
 #include "ace/Null_Mutex.h"
 #include "ace/Singleton.h"
 #include "ace/TSS_T.h"
-#include "ace/Auto_Ptr.h"
 #include "tao/AnyTypeCode/Any.h"
 #include "tao/DynamicInterface/Unknown_User_Exception.h"
 #include "tao/debug.h"
+#include <memory>
 
 #define RUBY_INVOKE_FUNC RUBY_ALLOC_FUNC
 
@@ -113,7 +113,6 @@ private:
       objreg->clear_registry ();
     }
   }
-
 };
 
 VALUE R2TAO_ObjectRegistry::registry_anchor_ = Qnil;
@@ -145,7 +144,7 @@ extern "C" R2TAO_EXPORT void Init_libr2tao()
   VALUE klass = rb_define_module_under (rb_eval_string ("::R2CORBA"), "TAO");
   rb_define_const (klass, "MAJOR_VERSION", INT2NUM (TAO_MAJOR_VERSION));
   rb_define_const (klass, "MINOR_VERSION", INT2NUM (TAO_MINOR_VERSION));
-  rb_define_const (klass, "BETA_VERSION", INT2NUM (TAO_BETA_VERSION));
+  rb_define_const (klass, "MICRO_VERSION", INT2NUM (TAO_MICRO_VERSION));
   rb_define_const (klass, "VERSION", rb_str_new2 (TAO_VERSION));
   rb_define_const (klass, "RUBY_THREAD_SUPPORT",
 #ifdef R2TAO_THREAD_SAFE
@@ -204,7 +203,6 @@ R2TAO_EXPORT void r2tao_unregister_object(VALUE rbobj)
 }
 
 #if defined (R2TAO_THREAD_SAFE)
-
 class R2TAO_GVLGuard
 {
 public:
@@ -232,7 +230,7 @@ private:
     ~TSSManager ()
     {
       delete gvl_indicator_;
-      gvl_indicator_ = 0;
+      gvl_indicator_ = nullptr;
     }
 
     static void set_indicator (bool val)
@@ -279,21 +277,12 @@ void* r2tao_call_with_gvl (void *data)
   return (*arg.func_) (arg.data_);
 }
 
-# if RUBY_VER_MAJOR < 2
-VALUE r2tao_call_without_gvl (void *data)
-{
-  R2TAO_GVLGuard gvl_guard_ (false);
-  r2tao_gvl_call_arg<VALUE(*)(void*)>& arg = *reinterpret_cast<r2tao_gvl_call_arg<VALUE(*)(void*)>*> (data);
-  return (*arg.func_) (arg.data_);
-}
-# else
 void* r2tao_call_without_gvl (void *data)
 {
   R2TAO_GVLGuard gvl_guard_ (false);
   r2tao_gvl_call_arg<void*(*)(void*)>& arg = *reinterpret_cast<r2tao_gvl_call_arg<void*(*)(void*)>*> (data);
   return (*arg.func_) (arg.data_);
 }
-# endif
 #endif
 
 R2TAO_EXPORT void* r2tao_call_thread_safe (void *(*func)(void *), void *data)
@@ -314,12 +303,8 @@ R2TAO_EXPORT VALUE r2tao_blocking_call (VALUE (*func)(void*), void*data)
   if (R2TAO_GVLGuard::gvl_locked (true))
   {
     r2tao_gvl_call_arg<VALUE(*)(void*)> arg(func, data);
-# if RUBY_VER_MAJOR < 2
-    return rb_thread_call_without_gvl(r2tao_call_without_gvl, &arg, RUBY_UBF_IO, 0);
-# else
     void *rc = rb_thread_call_without_gvl(r2tao_call_without_gvl, &arg, RUBY_UBF_IO, 0);
     return reinterpret_cast<VALUE> (rc);
-# endif
   }
 #endif
   return (*func) (data);
@@ -332,14 +317,9 @@ R2TAO_EXPORT VALUE r2tao_blocking_call_ex (VALUE (*func)(void*), void*data,
   if (R2TAO_GVLGuard::gvl_locked (true))
   {
     r2tao_gvl_call_arg<VALUE(*)(void*)> arg(func, data);
-# if RUBY_VER_MAJOR < 2
-    return rb_thread_call_without_gvl(r2tao_call_without_gvl, &arg,
-                                      unblock_func, unblock_data);
-# else
     void *rc = rb_thread_call_without_gvl(r2tao_call_without_gvl, &arg,
                                           unblock_func, unblock_data);
     return reinterpret_cast<VALUE> (rc);
-# endif
   }
 #else
   ACE_UNUSED_ARG(unblock_func);
@@ -362,10 +342,6 @@ R2TAO_RBFuncall::R2TAO_RBFuncall (const char* fn, bool throw_on_ex)
 {
 }
 
-R2TAO_RBFuncall::~R2TAO_RBFuncall ()
-{
-}
-
 VALUE R2TAO_RBFuncall::invoke (VALUE rcvr, VALUE args)
 {
   return this->_invoke (FuncArgArray (rcvr, args));
@@ -420,7 +396,7 @@ VALUE R2TAO_RBFuncall::_invoke (const FuncArgs& fa)
         _exc->completed (
           static_cast<CORBA::CompletionStatus> (NUM2ULONG (rb_iv_get (rexc, "@completed"))));
 
-        ACE_Auto_Basic_Ptr<CORBA::SystemException> e_ptr(_exc);
+        std::unique_ptr<CORBA::SystemException> e_ptr(_exc);
         _exc->_raise ();
       }
       else