Merge pull request #1486 from jwillemsen/jwi-misleadingindent

Fixed misleading indent warning

11 files changed, 153 insertions, 177 deletions

diff --git a/TAO/tao/RTScheduling/Current.cpp b/TAO/tao/RTScheduling/Current.cpp
index 4cb6456e278..2c23be762b7 100644
--- a/TAO/tao/RTScheduling/Current.cpp
+++ b/TAO/tao/RTScheduling/Current.cpp
@@ -20,12 +20,7 @@ TAO_DTId_Hash::operator () (const IdType &id) const
                         id.length ());
 }
 
-TAO_RTScheduler_Current::TAO_RTScheduler_Current (void) :
-  orb_ (0)
-{
-}
-
-TAO_RTScheduler_Current::~TAO_RTScheduler_Current (void)
+TAO_RTScheduler_Current::~TAO_RTScheduler_Current ()
 {
 }
 
@@ -52,18 +47,17 @@ TAO_RTScheduler_Current::rt_current (RTCORBA::Current_ptr rt_current)
 }
 
 TAO_ORB_Core*
-TAO_RTScheduler_Current::orb (void)
+TAO_RTScheduler_Current::orb ()
 {
   return this->orb_;
 }
 
 DT_Hash_Map*
-TAO_RTScheduler_Current::dt_hash (void)
+TAO_RTScheduler_Current::dt_hash ()
 {
   return &this->dt_hash_;
 }
 
-
 void
 TAO_RTScheduler_Current::begin_scheduling_segment (
     const char * name,
@@ -91,7 +85,6 @@ TAO_RTScheduler_Current::begin_scheduling_segment (
                                   implicit_sched_param);
 }
 
-
 void
 TAO_RTScheduler_Current::update_scheduling_segment (const char * name,
                                                     CORBA::Policy_ptr sched_param,
@@ -137,7 +130,6 @@ TAO_RTScheduler_Current::lookup(const RTScheduling::Current::IdType & id)
 // returns a null reference if
 // the distributable thread is
 // not known to the local scheduler
-
 RTScheduling::DistributableThread_ptr
 TAO_RTScheduler_Current::spawn (RTScheduling::ThreadAction_ptr start,
                                 CORBA::VoidData data,
@@ -243,19 +235,19 @@ TAO_RTScheduler_Current::implementation (void)
 }
 
 TAO_ORB_Core*
-TAO_RTScheduler_Current_i::orb (void)
+TAO_RTScheduler_Current_i::orb ()
 {
   return this->orb_;
 }
 
 DT_Hash_Map*
-TAO_RTScheduler_Current_i::dt_hash (void)
+TAO_RTScheduler_Current_i::dt_hash ()
 {
   return this->dt_hash_;
 }
 
  RTScheduling::Scheduler_ptr
-TAO_RTScheduler_Current_i::scheduler (void)
+TAO_RTScheduler_Current_i::scheduler ()
 {
   return RTScheduling::Scheduler::_duplicate (this->scheduler_.in ());
 }
@@ -299,7 +291,7 @@ TAO_RTScheduler_Current_i::TAO_RTScheduler_Current_i (
   this->scheduler_ = RTScheduling::Scheduler::_narrow (scheduler_obj.in ());
 }
 
-TAO_RTScheduler_Current_i::~TAO_RTScheduler_Current_i (void)
+TAO_RTScheduler_Current_i::~TAO_RTScheduler_Current_i ()
 {
 }
 
@@ -447,7 +439,6 @@ TAO_RTScheduler_Current_i::end_scheduling_segment (const char * name)
     }
 }
 
-
 // returns a null reference if
 // the distributable thread is
 // not known to the local scheduler
@@ -574,13 +565,13 @@ DTTask::DTTask (TAO_ORB_Core *orb,
 {
 }
 
-DTTask::~DTTask (void)
+DTTask::~DTTask ()
 {
   delete this->current_;
 }
 
 int
-DTTask::svc (void)
+DTTask::svc ()
 {
   try
     {
@@ -609,7 +600,7 @@ DTTask::svc (void)
 }
 
 RTScheduling::Current::IdType *
-TAO_RTScheduler_Current_i::id (void)
+TAO_RTScheduler_Current_i::id ()
 {
 
   RTScheduling::Current::IdType_var guid = this->guid_;
@@ -618,13 +609,13 @@ TAO_RTScheduler_Current_i::id (void)
 
 
 CORBA::Policy_ptr
-TAO_RTScheduler_Current_i::scheduling_parameter (void)
+TAO_RTScheduler_Current_i::scheduling_parameter ()
 {
   return CORBA::Policy::_duplicate (this->sched_param_.in ());
 }
 
 CORBA::Policy_ptr
-TAO_RTScheduler_Current_i::implicit_scheduling_parameter (void)
+TAO_RTScheduler_Current_i::implicit_scheduling_parameter ()
 {
   return CORBA::Policy::_duplicate (this->implicit_sched_param_.in ());
 }
@@ -650,7 +641,7 @@ TAO_RTScheduler_Current_i::current_scheduling_segment_names (void)
 }
 
 const char*
-TAO_RTScheduler_Current_i::name (void)
+TAO_RTScheduler_Current_i::name ()
 {
   return this->name_.in ();
 }
@@ -660,7 +651,7 @@ TAO_RTScheduler_Current_i::name (void)
 #endif /* THREAD_CANCELLED */
 
 void
-TAO_RTScheduler_Current_i::cancel_thread (void)
+TAO_RTScheduler_Current_i::cancel_thread ()
 {
   size_t guid;
   ACE_OS::memcpy (&guid,
@@ -685,14 +676,14 @@ TAO_RTScheduler_Current_i::cancel_thread (void)
 }
 
 void
-TAO_RTScheduler_Current_i::cleanup_DT (void)
+TAO_RTScheduler_Current_i::cleanup_DT ()
 {
   // Remove DT from map.
   this->dt_hash_->unbind (this->guid_);
 }
 
 void
-TAO_RTScheduler_Current_i::cleanup_current (void)
+TAO_RTScheduler_Current_i::cleanup_current ()
 {
   TAO_TSS_Resources *tss =
     TAO_TSS_Resources::instance ();
@@ -704,7 +695,7 @@ TAO_RTScheduler_Current_i::cleanup_current (void)
 }
 
 void
-TAO_RTScheduler_Current_i::delete_all_currents (void)
+TAO_RTScheduler_Current_i::delete_all_currents ()
 {
   TAO_RTScheduler_Current_i* current = this;
 
@@ -734,7 +725,7 @@ TAO_RTScheduler_Current_i::name (const char * name)
 }
 
 RTScheduling::DistributableThread_ptr
-TAO_RTScheduler_Current_i::DT (void)
+TAO_RTScheduler_Current_i::DT ()
 {
   return this->dt_._retn ();
 }
@@ -763,7 +754,6 @@ TAO_RTScheduler_Current_i::implicit_scheduling_parameter (CORBA::Policy_ptr impl
 // *************************************************************
 // Operations for class TAO_RTScheduler_Current_var
 // *************************************************************
-
 TAO_RTScheduler_Current_var::TAO_RTScheduler_Current_var () // default constructor
   : ptr_ (TAO_RTScheduler_Current::_nil ())
 {}
@@ -826,13 +816,13 @@ TAO_RTScheduler_Current_var::in () const
 }
 
 TAO_RTScheduler_Current_ptr &
-TAO_RTScheduler_Current_var::inout (void)
+TAO_RTScheduler_Current_var::inout ()
 {
   return this->ptr_;
 }
 
 TAO_RTScheduler_Current_ptr &
-TAO_RTScheduler_Current_var::out (void)
+TAO_RTScheduler_Current_var::out ()
 {
   ::CORBA::release (this->ptr_);
   this->ptr_ = ::TAO_RTScheduler_Current::_nil ();
@@ -840,7 +830,7 @@ TAO_RTScheduler_Current_var::out (void)
 }
 
 TAO_RTScheduler_Current_ptr
-TAO_RTScheduler_Current_var::_retn (void)
+TAO_RTScheduler_Current_var::_retn ()
 {
   // yield ownership of managed obj reference
   ::TAO_RTScheduler_Current_ptr val = this->ptr_;
@@ -861,7 +851,7 @@ TAO_RTScheduler_Current_var::release (TAO_RTScheduler_Current_ptr p)
 }
 
 TAO_RTScheduler_Current_ptr
-TAO_RTScheduler_Current_var::nil (void)
+TAO_RTScheduler_Current_var::nil ()
 {
   return ::TAO_RTScheduler_Current::_nil ();
 }
diff --git a/TAO/tao/RTScheduling/Current.h b/TAO/tao/RTScheduling/Current.h
index 3cba1c6667b..87959bbc07a 100644
--- a/TAO/tao/RTScheduling/Current.h
+++ b/TAO/tao/RTScheduling/Current.h
@@ -3,12 +3,9 @@
 //=============================================================================
 /**
  *  @file   Current.h
- *
- *  @author
  */
 //=============================================================================
 
-
 #ifndef TAO_RTSCHEDULER_CURRENT_H
 #define TAO_RTSCHEDULER_CURRENT_H
 
@@ -44,12 +41,10 @@ typedef TAO::unbounded_value_sequence<CORBA::Octet> IdType;
 class TAO_RTScheduler_Export TAO_DTId_Hash
 {
 public:
-
   /// Returns hash value.
   u_long operator () (const IdType &id) const;
 };
 
-
 typedef ACE_Hash_Map_Manager_Ex<IdType,
                                 RTScheduling::DistributableThread_var,
                                 TAO_DTId_Hash,
@@ -80,61 +75,60 @@ class TAO_RTScheduler_Export TAO_RTScheduler_Current
  public:
   static std::atomic<long> guid_counter;
 
-  TAO_RTScheduler_Current (void);
-  virtual ~TAO_RTScheduler_Current (void);
+  TAO_RTScheduler_Current () = default;
+  virtual ~TAO_RTScheduler_Current ();
 
   void init (TAO_ORB_Core* orb);
 
-  virtual RTCORBA::Priority the_priority (void);
+  RTCORBA::Priority the_priority () override;
 
-  virtual void the_priority (RTCORBA::Priority the_priority);
+  void the_priority (RTCORBA::Priority the_priority) override;
 
   void rt_current (RTCORBA::Current_ptr rt_current);
 
-  virtual void begin_scheduling_segment
+  void begin_scheduling_segment
     (const char * name,
      CORBA::Policy_ptr sched_param,
-     CORBA::Policy_ptr implicit_sched_param);
+     CORBA::Policy_ptr implicit_sched_param) override;
 
-  virtual void update_scheduling_segment
+  void update_scheduling_segment
     (const char * name,
      CORBA::Policy_ptr sched_param,
-     CORBA::Policy_ptr implicit_sched_param);
+     CORBA::Policy_ptr implicit_sched_param) override;
 
-  virtual void end_scheduling_segment (const char * name);
+  void end_scheduling_segment (const char * name) override;
 
-  virtual RTScheduling::DistributableThread_ptr
-    lookup(const RTScheduling::Current::IdType & id);
+  RTScheduling::DistributableThread_ptr
+    lookup(const RTScheduling::Current::IdType & id) override;
 
   // returns a null reference if
   // the distributable thread is
   // not known to the local scheduler
-
-  virtual RTScheduling::DistributableThread_ptr
+  RTScheduling::DistributableThread_ptr
     spawn (RTScheduling::ThreadAction_ptr start,
            CORBA::VoidData data,
            const char* name,
            CORBA::Policy_ptr sched_param,
            CORBA::Policy_ptr implicit_sched_param,
            CORBA::ULong stack_size,
-           RTCORBA::Priority base_priority);
+           RTCORBA::Priority base_priority) override;
 
-  virtual ::RTScheduling::Current::IdType *id (void);
+  ::RTScheduling::Current::IdType *id () override;
 
-  virtual ::CORBA::Policy_ptr scheduling_parameter (void);
+  ::CORBA::Policy_ptr scheduling_parameter () override;
 
-  virtual ::CORBA::Policy_ptr implicit_scheduling_parameter (void);
+  ::CORBA::Policy_ptr implicit_scheduling_parameter ()  override;
 
-  virtual ::RTScheduling::Current::NameList *
-    current_scheduling_segment_names (void);
+  ::RTScheduling::Current::NameList *
+    current_scheduling_segment_names () override;
 
-  TAO_RTScheduler_Current_i* implementation (void);
+  TAO_RTScheduler_Current_i* implementation ();
 
   TAO_RTScheduler_Current_i* implementation (TAO_RTScheduler_Current_i*);
 
-  TAO_ORB_Core* orb (void);
+  TAO_ORB_Core* orb ();
 
-  DT_Hash_Map* dt_hash (void);
+  DT_Hash_Map* dt_hash ();
 
   /**
    * @name Reference Related Methods
@@ -155,15 +149,12 @@ class TAO_RTScheduler_Export TAO_RTScheduler_Current
   virtual const char* _interface_repository_id () const;
   //@}
 
- private:
+private:
   RTCORBA::Current_var rt_current_;
-  TAO_ORB_Core* orb_;
+  TAO_ORB_Core* orb_ {};
   DT_Hash_Map dt_hash_;
-
 };
 
-
-
 /**
  * @class TAO_RTScheduler_Current_var
  */
@@ -171,11 +162,10 @@ class TAO_RTScheduler_Export TAO_RTScheduler_Current_var
   : private TAO_Base_var
 {
 public:
-
-  TAO_RTScheduler_Current_var (void); // default constructor
+  TAO_RTScheduler_Current_var (); // default constructor
   TAO_RTScheduler_Current_var (TAO_RTScheduler_Current_ptr p) : ptr_ (p) {}
   TAO_RTScheduler_Current_var (const TAO_RTScheduler_Current_var &); // copy constructor
-  ~TAO_RTScheduler_Current_var (void); // destructor
+  ~TAO_RTScheduler_Current_var (); // destructor
 
   TAO_RTScheduler_Current_var &operator= (TAO_RTScheduler_Current_ptr);
   TAO_RTScheduler_Current_var &operator= (const TAO_RTScheduler_Current_var &);
@@ -185,9 +175,9 @@ public:
   operator TAO_RTScheduler_Current_ptr &();
   // in, inout, out, _retn
   TAO_RTScheduler_Current_ptr in () const;
-  TAO_RTScheduler_Current_ptr &inout (void);
-  TAO_RTScheduler_Current_ptr &out (void);
-  TAO_RTScheduler_Current_ptr _retn (void);
+  TAO_RTScheduler_Current_ptr &inout ();
+  TAO_RTScheduler_Current_ptr &out ();
+  TAO_RTScheduler_Current_ptr _retn ();
   TAO_RTScheduler_Current_ptr ptr () const;
 
   // Hooks used by template sequence and object manager classes
@@ -199,19 +189,14 @@ public:
   static CORBA::Object * upcast (void *);
 
 private:
-
   TAO_RTScheduler_Current_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  TAO_RTScheduler_Current_var (const TAO_Base_var &rhs);
-  TAO_RTScheduler_Current_var &operator= (const TAO_Base_var &rhs);
-
+  TAO_RTScheduler_Current_var (const TAO_Base_var &rhs) = delete;
+  TAO_RTScheduler_Current_var &operator= (const TAO_Base_var &rhs) = delete;
 };
 
-
 class TAO_RTScheduler_Export TAO_RTScheduler_Current_i
 {
- public:
-
+public:
   TAO_RTScheduler_Current_i (TAO_ORB_Core* orb,
                              DT_Hash_Map* dt_hash);
 
@@ -224,7 +209,7 @@ class TAO_RTScheduler_Export TAO_RTScheduler_Current_i
                              RTScheduling::DistributableThread_ptr dt,
                              TAO_RTScheduler_Current_i* prev_current);
 
-  virtual ~TAO_RTScheduler_Current_i (void);
+  virtual ~TAO_RTScheduler_Current_i ();
 
   virtual RTScheduling::DistributableThread_ptr
     spawn (RTScheduling::ThreadAction_ptr start,
@@ -247,43 +232,43 @@ class TAO_RTScheduler_Export TAO_RTScheduler_Current_i
 
   virtual void end_scheduling_segment (const char * name);
 
-  virtual RTScheduling::Current::IdType *id (void);
+  virtual RTScheduling::Current::IdType *id ();
 
 
   void id (RTScheduling::Current::IdType guid);
 
-  virtual CORBA::Policy_ptr scheduling_parameter (void);
+  virtual CORBA::Policy_ptr scheduling_parameter ();
 
-  virtual CORBA::Policy_ptr implicit_scheduling_parameter (void);
+  virtual CORBA::Policy_ptr implicit_scheduling_parameter ();
 
   void scheduling_parameter (CORBA::Policy_ptr);
 
   void implicit_scheduling_parameter (CORBA::Policy_ptr);
 
   virtual RTScheduling::Current::NameList *
-    current_scheduling_segment_names (void);
+    current_scheduling_segment_names ();
 
-  void cancel_thread (void);
+  void cancel_thread ();
 
-  void cleanup_DT (void);
+  void cleanup_DT ();
 
-  void cleanup_current (void);
+  void cleanup_current ();
 
-  void delete_all_currents (void);
+  void delete_all_currents ();
 
   const char* name (void);
   void name (const char *);
 
-  TAO_ORB_Core* orb (void);
+  TAO_ORB_Core* orb ();
 
-  RTScheduling::Scheduler_ptr scheduler (void);
+  RTScheduling::Scheduler_ptr scheduler ();
 
-  DT_Hash_Map* dt_hash (void);
+  DT_Hash_Map* dt_hash ();
 
-  RTScheduling::DistributableThread_ptr DT (void);
+  RTScheduling::DistributableThread_ptr DT ();
   void DT (RTScheduling::DistributableThread_ptr);
 
- private:
+private:
   RTScheduling::Scheduler_var scheduler_;
   TAO_ORB_Core* orb_;
   RTScheduling::Current::IdType guid_;
@@ -308,16 +293,15 @@ public:
           CORBA::Policy_ptr sched_param,
           CORBA::Policy_ptr implicit_sched_param);
 
-  virtual ~DTTask (void);
+  virtual ~DTTask ();
 
   int activate_task (RTCORBA::Priority base_priority,
                      CORBA::ULong stack_size);
 
-  virtual int svc ();
+  int svc () override;
 
- private:
+private:
   TAO_ORB_Core* orb_;
-  // DT_Hash_Map* dt_hash_;
   TAO_RTScheduler_Current_i* current_;
   RTScheduling::ThreadAction_var start_;
   CORBA::VoidData data_;
diff --git a/TAO/tao/RTScheduling/Distributable_Thread.h b/TAO/tao/RTScheduling/Distributable_Thread.h
index dd4b9ccab81..b980148eee7 100644
--- a/TAO/tao/RTScheduling/Distributable_Thread.h
+++ b/TAO/tao/RTScheduling/Distributable_Thread.h
@@ -12,16 +12,15 @@ class TAO_RTScheduler_Export TAO_DistributableThread:
   public RTScheduling::DistributableThread,
   public ::CORBA::LocalObject
 {
- public:
+public:
   TAO_DistributableThread () = default;
-
   ~TAO_DistributableThread () = default;
 
   void cancel () override;
 
   RTScheduling::DistributableThread::DT_State state () override;
 
- private:
+private:
   RTScheduling::DistributableThread::DT_State state_ {RTScheduling::DistributableThread::ACTIVE};
 };
 
diff --git a/TAO/tao/RTScheduling/RTScheduler.cpp b/TAO/tao/RTScheduling/RTScheduler.cpp
index 938f09b7d94..8411950e393 100644
--- a/TAO/tao/RTScheduling/RTScheduler.cpp
+++ b/TAO/tao/RTScheduling/RTScheduler.cpp
@@ -3,7 +3,7 @@
 
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-TAO_RTScheduler_Initializer::TAO_RTScheduler_Initializer (void)
+TAO_RTScheduler_Initializer::TAO_RTScheduler_Initializer ()
 {
   ACE_Service_Config::process_directive (ace_svc_desc_TAO_RTScheduler_Loader);
 }
diff --git a/TAO/tao/RTScheduling/RTScheduler.h b/TAO/tao/RTScheduling/RTScheduler.h
index 2ac1e1cb8c2..623cdccc9ed 100644
--- a/TAO/tao/RTScheduling/RTScheduler.h
+++ b/TAO/tao/RTScheduling/RTScheduler.h
@@ -28,7 +28,7 @@ class TAO_RTScheduler_Export TAO_RTScheduler_Initializer
 {
 public:
   // Constructor.
-  TAO_RTScheduler_Initializer (void);
+  TAO_RTScheduler_Initializer ();
 };
 
 static TAO_RTScheduler_Initializer TAO_RTScheduler_initializer;
diff --git a/TAO/tao/RTScheduling/RTScheduler_Initializer.h b/TAO/tao/RTScheduling/RTScheduler_Initializer.h
index aca50cc312e..0ba5f293488 100644
--- a/TAO/tao/RTScheduling/RTScheduler_Initializer.h
+++ b/TAO/tao/RTScheduling/RTScheduler_Initializer.h
@@ -40,9 +40,9 @@ class TAO_RTScheduler_ORB_Initializer
   , public virtual ::CORBA::LocalObject
 {
 public:
-  virtual void pre_init (PortableInterceptor::ORBInitInfo_ptr info);
+  void pre_init (PortableInterceptor::ORBInitInfo_ptr info) override;
 
-  virtual void post_init (PortableInterceptor::ORBInitInfo_ptr info);
+  void post_init (PortableInterceptor::ORBInitInfo_ptr info) override;
 
 private:
   TAO_RTScheduler_Current_var current_;
diff --git a/TAO/tao/RTScheduling/RTScheduler_Loader.h b/TAO/tao/RTScheduling/RTScheduler_Loader.h
index 2aabc43029e..8ca3432c6bb 100644
--- a/TAO/tao/RTScheduling/RTScheduler_Loader.h
+++ b/TAO/tao/RTScheduling/RTScheduler_Loader.h
@@ -31,13 +31,13 @@ class TAO_RTScheduler_Export TAO_RTScheduler_Loader : public ACE_Service_Object
 {
 public:
   /// Constructor.
-  TAO_RTScheduler_Loader (void);
+  TAO_RTScheduler_Loader ();
 
   /// Destructor.
-  virtual ~TAO_RTScheduler_Loader (void);
+  virtual ~TAO_RTScheduler_Loader ();
 
   /// Initialize the RTScheduler loader hooks.
-  virtual int init (int argc, ACE_TCHAR* []);
+  int init (int argc, ACE_TCHAR* []) override;
 
 private:
   /// Set to true after init is called.
diff --git a/TAO/tao/RTScheduling/RTScheduler_Manager.cpp b/TAO/tao/RTScheduling/RTScheduler_Manager.cpp
index c592e98ac50..b0a9b4215b5 100644
--- a/TAO/tao/RTScheduling/RTScheduler_Manager.cpp
+++ b/TAO/tao/RTScheduling/RTScheduler_Manager.cpp
@@ -7,15 +7,6 @@
 
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
-TAO_RTScheduler_Manager::TAO_RTScheduler_Manager () :
-  orb_ (nullptr)
-{
-}
-
-TAO_RTScheduler_Manager::~TAO_RTScheduler_Manager ()
-{
-}
-
 TAO_RTScheduler_Manager_ptr
 TAO_RTScheduler_Manager::_narrow (CORBA::Object_ptr obj)
 {
diff --git a/TAO/tao/RTScheduling/RTScheduler_Manager.h b/TAO/tao/RTScheduling/RTScheduler_Manager.h
index f3b0513c27f..61bf6f7a8b1 100644
--- a/TAO/tao/RTScheduling/RTScheduler_Manager.h
+++ b/TAO/tao/RTScheduling/RTScheduler_Manager.h
@@ -8,7 +8,6 @@
  */
 //=============================================================================
 
-
 #ifndef TAO_RTSCHEDULER_MANAGER_H
 #define TAO_RTSCHEDULER_MANAGER_H
 
@@ -21,7 +20,6 @@ class TAO_RTScheduler_Manager;
 class TAO_RTScheduler_Manager_var;
 typedef TAO_RTScheduler_Manager *TAO_RTScheduler_Manager_ptr;
 
-
 /**
  * @class TAO_RTScheduler_Manager
  *
@@ -33,14 +31,14 @@ class TAO_RTScheduler_Export TAO_RTScheduler_Manager :
   public virtual ::CORBA::LocalObject
 {
 public:
-  TAO_RTScheduler_Manager (void);
+  TAO_RTScheduler_Manager () = default;
 
   /// Constructor.
   TAO_RTScheduler_Manager (TAO_ORB_Core* orb);
 
   void rtscheduler (RTScheduling::Scheduler_ptr rtscheduler);
 
-  RTScheduling::Scheduler_ptr rtscheduler (void);
+  RTScheduling::Scheduler_ptr rtscheduler ();
 
 public:
   typedef TAO_RTScheduler_Manager_ptr _ptr_type;
@@ -57,16 +55,14 @@ public:
   virtual const char* _interface_repository_id () const;
 
 protected:
-
   /// Protected destructor to enforce proper memory management of this
   /// reference counted object.
-  ~TAO_RTScheduler_Manager (void);
+  ~TAO_RTScheduler_Manager () = default;
 
 private:
-
-  TAO_RTScheduler_Manager (const TAO_RTScheduler_Manager &);
-  void operator= (const TAO_RTScheduler_Manager &);
-  TAO_ORB_Core* orb_;
+  TAO_RTScheduler_Manager (const TAO_RTScheduler_Manager &) = delete;
+  void operator= (const TAO_RTScheduler_Manager &) = delete;
+  TAO_ORB_Core* orb_ {};
 
 private:
   RTScheduling::Scheduler_var rtscheduler_;
@@ -103,10 +99,9 @@ public:
   static CORBA::Object * upcast (void *);
 
 private:
-  /// Unimplemented - prevents widening assignment.
   TAO_RTScheduler_Manager_ptr ptr_;
-  TAO_RTScheduler_Manager_var (const TAO_Base_var &rhs);
-  TAO_RTScheduler_Manager_var &operator= (const TAO_Base_var &rhs);
+  TAO_RTScheduler_Manager_var (const TAO_Base_var &rhs) = delete;
+  TAO_RTScheduler_Manager_var &operator= (const TAO_Base_var &rhs) = delete;
 };
 
 class TAO_RTScheduler_Export TAO_RTScheduler_Manager_out
@@ -119,8 +114,8 @@ public:
   TAO_RTScheduler_Manager_out &operator= (const TAO_RTScheduler_Manager_var &);
   TAO_RTScheduler_Manager_out &operator= (TAO_RTScheduler_Manager_ptr);
   operator TAO_RTScheduler_Manager_ptr &();
-  TAO_RTScheduler_Manager_ptr &ptr (void);
-  TAO_RTScheduler_Manager_ptr operator-> (void);
+  TAO_RTScheduler_Manager_ptr &ptr ();
+  TAO_RTScheduler_Manager_ptr operator-> ();
 
 private:
   TAO_RTScheduler_Manager_ptr &ptr_;
diff --git a/TAO/tao/RTScheduling/Request_Interceptor.cpp b/TAO/tao/RTScheduling/Request_Interceptor.cpp
index e27c5b49172..a69afc6dccc 100644
--- a/TAO/tao/RTScheduling/Request_Interceptor.cpp
+++ b/TAO/tao/RTScheduling/Request_Interceptor.cpp
@@ -114,27 +114,31 @@ void
 Client_Interceptor::send_poll (PortableInterceptor::ClientRequestInfo_ptr ri)
 {
   if (TAO_debug_level > 0)
-    TAOLIB_DEBUG ((LM_DEBUG,
-                "Client_Interceptor::send_poll\n"));
+    {
+      TAOLIB_DEBUG ((LM_DEBUG,
+                  "Client_Interceptor::send_poll\n"));
+    }
 
-    TAO_RTScheduler_Current_i *current = 0;
+  TAO_RTScheduler_Current_i *current = 0;
 
-    TAO_TSS_Resources *tss = TAO_TSS_Resources::instance ();
+  TAO_TSS_Resources *tss = TAO_TSS_Resources::instance ();
 
-    current = static_cast<TAO_RTScheduler_Current_i *> (tss->rtscheduler_current_impl_);
-    if (current != 0)
-      {
-        RTScheduling::Scheduler_var scheduler = current->scheduler ();
-        scheduler->send_poll (ri);
-      }
+  current = static_cast<TAO_RTScheduler_Current_i *> (tss->rtscheduler_current_impl_);
+  if (current != 0)
+    {
+      RTScheduling::Scheduler_var scheduler = current->scheduler ();
+      scheduler->send_poll (ri);
+    }
 }
 
 void
 Client_Interceptor::receive_reply (PortableInterceptor::ClientRequestInfo_ptr ri)
 {
   if (TAO_debug_level > 0)
-    TAOLIB_DEBUG ((LM_DEBUG,
-                "Client_Interceptor::receive_reply\n"));
+    {
+      TAOLIB_DEBUG ((LM_DEBUG,
+                  "Client_Interceptor::receive_reply\n"));
+    }
 
   TAO_RTScheduler_Current_i *current = 0;
 
@@ -152,8 +156,10 @@ void
 Client_Interceptor::receive_exception (PortableInterceptor::ClientRequestInfo_ptr ri)
 {
   if (TAO_debug_level > 0)
-    TAOLIB_DEBUG ((LM_DEBUG,
-                "Client_Interceptor::receive_exception\n"));
+    {
+      TAOLIB_DEBUG ((LM_DEBUG,
+                  "Client_Interceptor::receive_exception\n"));
+    }
 
   TAO_TSS_Resources *tss = TAO_TSS_Resources::instance ();
 
@@ -165,7 +171,7 @@ Client_Interceptor::receive_exception (PortableInterceptor::ClientRequestInfo_pt
       if (ri == 0)
         {
           TAOLIB_ERROR ((LM_ERROR,
-                      "ri = 0\n"));
+                      "Client_Interceptor::receive_exception ri = 0\n"));
           return;
         }
 
@@ -208,8 +214,10 @@ void
 Client_Interceptor::receive_other (PortableInterceptor::ClientRequestInfo_ptr ri)
 {
   if (TAO_debug_level > 0)
-    TAOLIB_DEBUG ((LM_DEBUG,
-                "Client_Interceptor::receive_other\n"));
+    {
+      TAOLIB_DEBUG ((LM_DEBUG,
+                  "Client_Interceptor::receive_other\n"));
+    }
 
   TAO_RTScheduler_Current_i *current = 0;
 
@@ -224,13 +232,13 @@ Client_Interceptor::receive_other (PortableInterceptor::ClientRequestInfo_ptr ri
 }
 
 char*
-Client_Interceptor::name (void)
+Client_Interceptor::name ()
 {
-  return  CORBA::string_dup ("RTSchdeuler_Client_Interceptor");
+  return CORBA::string_dup ("RTSchdeuler_Client_Interceptor");
 }
 
 void
-Client_Interceptor::destroy (void)
+Client_Interceptor::destroy ()
 {
 }
 
@@ -247,17 +255,20 @@ Server_Interceptor::receive_request_service_contexts (
   PortableInterceptor::ServerRequestInfo_ptr)
 {
   if (TAO_debug_level > 0)
-    TAOLIB_DEBUG ((LM_DEBUG,
-                "Server_Interceptor::receive_request_service_contexts\n"));
-
+    {
+      TAOLIB_DEBUG ((LM_DEBUG,
+                  "Server_Interceptor::receive_request_service_contexts\n"));
+    }
 }
 
 void
 Server_Interceptor::receive_request (PortableInterceptor::ServerRequestInfo_ptr ri)
 {
   if (TAO_debug_level > 0)
-    TAOLIB_DEBUG ((LM_DEBUG,
-                "Server_Interceptor::receive_request\n"));
+    {
+      TAOLIB_DEBUG ((LM_DEBUG,
+                  "Server_Interceptor::receive_request\n"));
+    }
 
   IOP::ServiceContext_var serv_cxt;
 
@@ -357,8 +368,10 @@ void
 Server_Interceptor::send_reply (PortableInterceptor::ServerRequestInfo_ptr ri)
 {
   if (TAO_debug_level > 0)
-    TAOLIB_DEBUG ((LM_DEBUG,
-                "Server_Interceptor::send_reply\n"));
+    {
+      TAOLIB_DEBUG ((LM_DEBUG,
+                  "Server_Interceptor::send_reply\n"));
+    }
 
   TAO_RTScheduler_Current_i *current = 0;
   TAO_RTScheduler_Current_i *prev_current = 0;
@@ -404,8 +417,10 @@ void
 Server_Interceptor::send_exception (PortableInterceptor::ServerRequestInfo_ptr ri)
 {
   if (TAO_debug_level > 0)
-    TAOLIB_DEBUG ((LM_DEBUG,
-                "Server_Interceptor::send_exception\n"));
+    {
+      TAOLIB_DEBUG ((LM_DEBUG,
+                  "Server_Interceptor::send_exception\n"));
+    }
 
   TAO_RTScheduler_Current_i *current = 0;
 
@@ -427,8 +442,10 @@ void
 Server_Interceptor::send_other (PortableInterceptor::ServerRequestInfo_ptr ri)
 {
   if (TAO_debug_level > 0)
-    TAOLIB_DEBUG ((LM_DEBUG,
-                "Server_Interceptor::send_other\n"));
+    {
+      TAOLIB_DEBUG ((LM_DEBUG,
+                  "Server_Interceptor::send_other\n"));
+    }
 
   TAO_RTScheduler_Current_i *current = 0;
 
@@ -447,13 +464,13 @@ Server_Interceptor::send_other (PortableInterceptor::ServerRequestInfo_ptr ri)
 }
 
 char*
-Server_Interceptor::name (void)
+Server_Interceptor::name ()
 {
     return  CORBA::string_dup ("RTSchdeuler_Server_Interceptor");
 }
 
 void
-Server_Interceptor::destroy (void)
+Server_Interceptor::destroy ()
 {
 }
 
diff --git a/TAO/tao/RTScheduling/Request_Interceptor.h b/TAO/tao/RTScheduling/Request_Interceptor.h
index 879d73a7876..772cb6b9753 100644
--- a/TAO/tao/RTScheduling/Request_Interceptor.h
+++ b/TAO/tao/RTScheduling/Request_Interceptor.h
@@ -21,19 +21,19 @@ class TAO_RTScheduler_Export Client_Interceptor:
 {
 public:
   //  Client_Interceptor (RTScheduling::Current_ptr current);
-  virtual void send_request (PortableInterceptor::ClientRequestInfo_ptr ri);
+  void send_request (PortableInterceptor::ClientRequestInfo_ptr ri) override;
 
-  virtual void send_poll (PortableInterceptor::ClientRequestInfo_ptr ri);
+  void send_poll (PortableInterceptor::ClientRequestInfo_ptr ri) override;
 
-  virtual void receive_reply (PortableInterceptor::ClientRequestInfo_ptr ri);
+  void receive_reply (PortableInterceptor::ClientRequestInfo_ptr ri) override;
 
-  virtual void receive_exception (PortableInterceptor::ClientRequestInfo_ptr ri);
+  void receive_exception (PortableInterceptor::ClientRequestInfo_ptr ri) override;
 
-  virtual void receive_other (PortableInterceptor::ClientRequestInfo_ptr ri);
+  void receive_other (PortableInterceptor::ClientRequestInfo_ptr ri) override;
 
-  virtual char* name (void);
+  char* name () override;
 
-  virtual void destroy (void);
+  void destroy () override;
 
   static const IOP::ServiceId SchedulingInfo;
 };
@@ -45,19 +45,19 @@ class TAO_RTScheduler_Export Server_Interceptor :
 public:
   Server_Interceptor (TAO_RTScheduler_Current_ptr current);
 
-  virtual void receive_request_service_contexts (PortableInterceptor::ServerRequestInfo_ptr ri);
+  void receive_request_service_contexts (PortableInterceptor::ServerRequestInfo_ptr ri) override;
 
-  virtual void receive_request (PortableInterceptor::ServerRequestInfo_ptr ri);
+  void receive_request (PortableInterceptor::ServerRequestInfo_ptr ri) override;
 
-  virtual void send_reply (PortableInterceptor::ServerRequestInfo_ptr ri);
+  void send_reply (PortableInterceptor::ServerRequestInfo_ptr ri) override;
 
-  virtual void send_exception (PortableInterceptor::ServerRequestInfo_ptr ri);
+  void send_exception (PortableInterceptor::ServerRequestInfo_ptr ri) override;
 
-  virtual void send_other (PortableInterceptor::ServerRequestInfo_ptr ri);
+  void send_other (PortableInterceptor::ServerRequestInfo_ptr ri) override;
 
-  virtual char* name (void);
+  char* name () override;
 
-  virtual void destroy (void);
+  void destroy () override;
 
   static const IOP::ServiceId SchedulingInfo;