ChangeLogTag:Thu Nov 3 09:16:23 2005 Ossama Othman <ossama@dre.vanderbilt.edu>

20 files changed, 163 insertions, 93 deletions

diff --git a/ace/Activation_Queue.h b/ace/Activation_Queue.h
index 7ded53ca766..c1ae425a302 100644
--- a/ace/Activation_Queue.h
+++ b/ace/Activation_Queue.h
@@ -145,7 +145,14 @@ public:
   /// Declare the dynamic allocation hooks.
   ACE_ALLOC_HOOK_DECLARE;
 
+private:
+
+  // = Prevent copying and assignment.
+  ACE_Activation_Queue (const ACE_Activation_Queue &);
+  void operator= (const ACE_Activation_Queue &);
+
 protected:
+
   /// Stores the Method_Requests.
   ACE_Message_Queue<ACE_SYNCH> *queue_;
 
@@ -153,15 +160,13 @@ protected:
   int delete_queue_;
 
 private:
+
   /// Allocation strategy of the queue.
   ACE_Allocator *allocator_;
 
   /// Allocation strategy of the message blocks.
   ACE_Allocator *data_block_allocator_;
 
-  // = Prevent assignment and initialization.
-  ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Activation_Queue &))
-  ACE_UNIMPLEMENTED_FUNC (ACE_Activation_Queue (const ACE_Activation_Queue &))
 };
 
 ACE_END_VERSIONED_NAMESPACE_DECL
diff --git a/ace/Atomic_Op.h b/ace/Atomic_Op.h
index c66664acaca..7454946a64f 100644
--- a/ace/Atomic_Op.h
+++ b/ace/Atomic_Op.h
@@ -1,4 +1,4 @@
-/* -*- C++ -*- */
+// -*- C++ -*-
 
 //=============================================================================
 /**
@@ -128,10 +128,13 @@ public:
   static void init_functions (void);
 
 private:
+
   // This function cannot be supported by this template specialization.
   // If you need access to an underlying lock, use the ACE_Atomic_Op_Ex
   // template instead.
-  ACE_UNIMPLEMENTED_FUNC (ACE_Thread_Mutex &mutex (void))
+  ACE_Thread_Mutex &mutex (void);
+
+private:
 
   /// Current object decorated by the atomic op.
   volatile long value_;
@@ -224,10 +227,13 @@ public:
   static void init_functions (void);
 
 private:
+
   // This function cannot be supported by this template specialization.
   // If you need access to an underlying lock, use the ACE_Atomic_Op_Ex
   // template instead.
-  ACE_UNIMPLEMENTED_FUNC (ACE_Thread_Mutex &mutex (void))
+  ACE_Thread_Mutex &mutex (void);
+
+private:
 
   /// Current object decorated by the atomic op.
   volatile unsigned long value_;
diff --git a/ace/Condition_Recursive_Thread_Mutex.h b/ace/Condition_Recursive_Thread_Mutex.h
index 6c3d648db10..0c4607a5c2e 100644
--- a/ace/Condition_Recursive_Thread_Mutex.h
+++ b/ace/Condition_Recursive_Thread_Mutex.h
@@ -87,15 +87,19 @@ public:
   void dump (void) const;
 
 private:
+
+  // = Prevent assignment and copying.
+  void operator= (const ACE_Condition<ACE_Recursive_Thread_Mutex> &);
+  ACE_Condition (const ACE_Condition<ACE_Recursive_Thread_Mutex> &);
+
+private:
+
   /// A normal (i.e., non-recursive) condition variable.
   ACE_cond_t cond_;
 
   /// Reference to the recursive mutex.
   ACE_Recursive_Thread_Mutex &mutex_;
 
-  // = Prevent assignment and initialization.
-  ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Condition<ACE_Recursive_Thread_Mutex> &))
-  ACE_UNIMPLEMENTED_FUNC (ACE_Condition (const ACE_Condition<ACE_Recursive_Thread_Mutex> &))
 };
 
 class ACE_Export ACE_Condition_Recursive_Thread_Mutex
diff --git a/ace/DLL.h b/ace/DLL.h
index 330da0f27c1..c46ebb81c32 100644
--- a/ace/DLL.h
+++ b/ace/DLL.h
@@ -126,6 +126,11 @@ private:
               ACE_SHLIB_HANDLE handle = 0);
 
 
+  // Disallow assignment since we don't handle it.
+  void operator= (const ACE_DLL &);
+
+private:
+
   /// Open mode.
   int open_mode_;
 
@@ -143,8 +148,6 @@ private:
   /// Flag to record if the last operation had an error.
   int error_;
 
-  // = Disallow copying and assignment since we don't handle these.
-  ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_DLL &))
 };
 
 ACE_END_VERSIONED_NAMESPACE_DECL
diff --git a/ace/DLL_Manager.h b/ace/DLL_Manager.h
index 142cce6c525..28f16329483 100644
--- a/ace/DLL_Manager.h
+++ b/ace/DLL_Manager.h
@@ -105,6 +105,7 @@ public:
   ACE_SHLIB_HANDLE get_handle (int become_owner = 0);
 
 private:
+
   /// Returns a pointer to a string explaining why <symbol> or <open>
   /// failed.  This is used internal to print out the error to the log,
   /// but since this object is shared, we can't store or return the error
@@ -117,6 +118,12 @@ private:
   void get_dll_names (const ACE_TCHAR *dll_name,
                       ACE_Array<ACE_TString> &try_names);
 
+  // Disallow copying and assignment since we don't handle them.
+  ACE_DLL_Handle (const ACE_DLL_Handle &);
+  void operator= (const ACE_DLL_Handle &);
+
+private:
+
   // Keep track of how many ACE_DLL objects have a reference to this
   // dll.
   sig_atomic_t refcount_;
@@ -137,11 +144,6 @@ private:
   /// Synchronization variable for the MT_SAFE Repository
   ACE_Thread_Mutex lock_;
 #endif /* ACE_MT_SAFE */
-
-  // = Disallow copying and assignment since we don't handle these.
-  ACE_UNIMPLEMENTED_FUNC (ACE_DLL_Handle (const ACE_DLL_Handle &))
-  ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_DLL_Handle &))
-
 };
 
 class ACE_Framework_Repository;
@@ -182,8 +184,6 @@ class ACE_Framework_Repository;
 class ACE_Export ACE_DLL_Manager
 {
 public:
-  // This if to silence the compiler warnings, even though ACE_Framework_Repository
-  // always uses the instance method.
   friend class ACE_Framework_Repository;
 
   enum
@@ -212,6 +212,13 @@ public:
   void unload_policy (u_long unload_policy);
 
 protected:
+
+  /// Default constructor.
+  ACE_DLL_Manager (int size = ACE_DLL_Manager::DEFAULT_SIZE);
+
+  /// Destructor.
+  ~ACE_DLL_Manager (void);
+
   // Allocate handle_vector_.
   int open (int size);
 
@@ -225,15 +232,16 @@ protected:
   int unload_dll (ACE_DLL_Handle *dll_handle, int force_unload = 0);
 
 private:
-  /// Default constructor.
-  ACE_DLL_Manager (int size = ACE_DLL_Manager::DEFAULT_SIZE);
-
-  /// Destructor.
-  ~ACE_DLL_Manager (void);
 
   /// Close the singleton instance.
   static void close_singleton (void);
 
+  // Disallow copying and assignment since we don't handle these.
+  ACE_DLL_Manager (const ACE_DLL_Manager &);
+  void operator= (const ACE_DLL_Manager &);
+
+private:
+
   /// Vector containing all loaded handle objects.
   ACE_DLL_Handle **handle_vector_;
 
@@ -254,9 +262,6 @@ private:
   ACE_Thread_Mutex lock_;
 #endif /* ACE_MT_SAFE */
 
- // = Disallow copying and assignment since we don't handle these.
-  ACE_UNIMPLEMENTED_FUNC (ACE_DLL_Manager (const ACE_DLL_Manager &))
-  ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_DLL_Manager &))
 };
 
 ACE_END_VERSIONED_NAMESPACE_DECL
diff --git a/ace/Dev_Poll_Reactor.h b/ace/Dev_Poll_Reactor.h
index b34fc2c8e13..6ed7ab3bba1 100644
--- a/ace/Dev_Poll_Reactor.h
+++ b/ace/Dev_Poll_Reactor.h
@@ -1203,7 +1203,12 @@ protected:
     /// does wake the current token holder.
     int acquire (ACE_Time_Value *max_wait = 0);
 
+  protected:
+
+    Token_Guard (void) {}
+
   private:
+
     /// The Reactor token.
     ACE_Dev_Poll_Reactor_Token &token_;
 
@@ -1213,9 +1218,6 @@ protected:
     /// vice-versa.
     int owner_;
 
-  private:
-
-    ACE_UNIMPLEMENTED_FUNC (Token_Guard (void))
   };
 
 };
diff --git a/ace/Framework_Component.h b/ace/Framework_Component.h
index bfcd053d7e4..5d1af80b004 100644
--- a/ace/Framework_Component.h
+++ b/ace/Framework_Component.h
@@ -147,12 +147,13 @@ public:
   /// Declare the dynamic allocation hooks.
   ACE_ALLOC_HOOK_DECLARE;
 
-private:
-  // = Initialization and termination methods.
+protected:
 
   /// Initialize the repository.
   ACE_Framework_Repository (int size = ACE_Framework_Repository::DEFAULT_SIZE);
 
+private:
+
   /// Actually removes the dll components, must be called with locks held.
   int remove_dll_components_i (const ACE_TCHAR *dll_name);
 
@@ -160,6 +161,12 @@ private:
   /// order.
   void compact (void);
 
+  /// Disallow copying and assignment.
+  ACE_Framework_Repository (const ACE_Framework_Repository &);
+  ACE_Framework_Repository &operator= (const ACE_Framework_Repository &);
+
+private:
+
   /// Contains all the framework components.
   ACE_Framework_Component **component_vector_;
 
@@ -183,9 +190,6 @@ private:
   ACE_Thread_Mutex lock_;
 #endif /* ACE_MT_SAFE */
 
-  /// Don't allow these to be called.
-  ACE_UNIMPLEMENTED_FUNC (ACE_Framework_Repository (const ACE_Framework_Repository &))
-  ACE_UNIMPLEMENTED_FUNC (ACE_Framework_Repository &operator= (const ACE_Framework_Repository &))
 };
 
 ACE_END_VERSIONED_NAMESPACE_DECL
diff --git a/ace/Get_Opt.h b/ace/Get_Opt.h
index 5cba19a17c7..73a18f6a051 100644
--- a/ace/Get_Opt.h
+++ b/ace/Get_Opt.h
@@ -369,7 +369,7 @@ private:
                              int has_arg,
                              int val = 0);
 
-    /// Default dtor.
+    /// Dtor.
     ~ACE_Get_Opt_Long_Option (void);
 
     bool operator < (const ACE_Get_Opt_Long_Option &rhs);
@@ -409,6 +409,12 @@ private:
   /// Set last_option.
   void last_option (const ACE_TString &s);
 
+  // Disallow copying and assignment.
+  ACE_Get_Opt (const ACE_Get_Opt &);
+  ACE_Get_Opt &operator= (const ACE_Get_Opt &);
+
+private:
+
   /// Holds the option string.
   ACE_TString *optstring_;
 
@@ -456,8 +462,6 @@ private:
   /// Declare the dynamic allocation hooks.
   ACE_ALLOC_HOOK_DECLARE;
 
-  ACE_UNIMPLEMENTED_FUNC (ACE_Get_Opt (const ACE_Get_Opt &))
-  ACE_UNIMPLEMENTED_FUNC (ACE_Get_Opt &operator= (const ACE_Get_Opt &))
 };
 
 ACE_END_VERSIONED_NAMESPACE_DECL
diff --git a/ace/Mem_Map.h b/ace/Mem_Map.h
index b47eede9250..3163730a0d0 100644
--- a/ace/Mem_Map.h
+++ b/ace/Mem_Map.h
@@ -180,6 +180,23 @@ public:
   ACE_ALLOC_HOOK_DECLARE;
 
 private:
+
+  /// This method does the dirty work of actually calling ::mmap to map
+  /// the file into memory.
+  int map_it (ACE_HANDLE handle,
+              int len = -1,
+              int prot = PROT_RDWR,
+              int share = MAP_SHARED,
+              void *addr = 0,
+              off_t offset = 0,
+              LPSECURITY_ATTRIBUTES sa = 0);
+
+  // = Disallow copying and assignment.
+  ACE_Mem_Map (const ACE_Mem_Map &);
+  void operator = (const ACE_Mem_Map &);
+
+private:
+
   /// Base address of the memory-mapped file.
   void *base_addr_;
 
@@ -204,22 +221,9 @@ private:
   /// if we opened the file.
   int close_handle_;
 
-  /// This method does the dirty work of actually calling ::mmap to map
-  /// the file into memory.
-  int map_it (ACE_HANDLE handle,
-              int len = -1,
-              int prot = PROT_RDWR,
-              int share = MAP_SHARED,
-              void *addr = 0,
-              off_t offset = 0,
-              LPSECURITY_ATTRIBUTES sa = 0);
-
-  // = Disallow copying and assignment.
-  ACE_UNIMPLEMENTED_FUNC (ACE_Mem_Map (const ACE_Mem_Map &))
-  ACE_UNIMPLEMENTED_FUNC (void operator = (const ACE_Mem_Map &))
 };
 
-ACE_BEGIN_VERSIONED_NAMESPACE_DECL
+ACE_END_VERSIONED_NAMESPACE_DECL
 
 #if defined (__ACE_INLINE__)
 #include "ace/Mem_Map.inl"
diff --git a/ace/Message_Queue.cpp b/ace/Message_Queue.cpp
index f35a0824fe1..1a01ff2e202 100644
--- a/ace/Message_Queue.cpp
+++ b/ace/Message_Queue.cpp
@@ -371,9 +371,8 @@ ACE_Message_Queue_Vx::wait_not_empty_cond (ACE_Guard<ACE_Null_Mutex> &mon,
 #if ! defined (ACE_NEEDS_FUNC_DEFINITIONS)
 int
 ACE_Message_Queue_Vx::peek_dequeue_head (ACE_Message_Block *&,
-                                         ACE_Time_Value *tv)
+                                         ACE_Time_Value *)
 {
-  ACE_UNUSED_ARG (tv);
   ACE_NOTSUP_RETURN (-1);
 }
 #endif /* ! ACE_NEEDS_FUNC_DEFINITIONS */
diff --git a/ace/Message_Queue.h b/ace/Message_Queue.h
index dc0b67e094b..7cda53cf185 100644
--- a/ace/Message_Queue.h
+++ b/ace/Message_Queue.h
@@ -208,15 +208,16 @@ public:
   /// Declare the dynamic allocation hooks.
   ACE_ALLOC_HOOK_DECLARE;
 
+private:
+  // = Disallow copying and assignment.
+  ACE_Message_Queue_Base (const ACE_Message_Queue_Base &);
+  void operator= (const ACE_Message_Queue_Base &);
+
 protected:
   /// Indicates the state of the queue, which can be
   /// <ACTIVATED>, <DEACTIVATED>, or <PULSED>.
   int state_;
 
-private:
-  // = Disallow these operations.
-  ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Message_Queue_Base &))
-  ACE_UNIMPLEMENTED_FUNC (ACE_Message_Queue_Base (const ACE_Message_Queue_Base &))
 };
 
 // Include the templates here.
@@ -390,6 +391,16 @@ protected:
   MSG_Q_ID msgq (void);
 
 private:
+
+  // Disallow copying and assignment.
+  ACE_Message_Queue_Vx (const ACE_Message_Queue_Vx &);
+  void operator= (const ACE_Message_Queue_Vx &);
+  
+  ACE_UNIMPLEMENTED_FUNC (virtual int peek_dequeue_head
+                            (ACE_Message_Block *&first_item,
+                             ACE_Time_Value *tv = 0))
+
+private:
   /// Maximum number of messages that can be queued.
   int max_messages_;
 
@@ -399,13 +410,6 @@ private:
   /// Native message queue options.
   int options_;
 
-  // = Disallow these operations.
-  ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Message_Queue_Vx &))
-  ACE_UNIMPLEMENTED_FUNC (ACE_Message_Queue_Vx (const ACE_Message_Queue_Vx &))
-
-  ACE_UNIMPLEMENTED_FUNC (virtual int peek_dequeue_head
-                            (ACE_Message_Block *&first_item,
-                             ACE_Time_Value *tv = 0))
 };
 #endif /* VXWORKS */
 
@@ -567,6 +571,12 @@ public:
   ACE_ALLOC_HOOK_DECLARE;
 
 private:
+
+  // Disallow copying and assignment.
+  ACE_Message_Queue_NT (const ACE_Message_Queue_NT &);
+  void operator= (const ACE_Message_Queue_NT &);
+
+private:
   // = Internal states.
 
   /// Maximum threads that can be released (and run) concurrently.
@@ -594,9 +604,6 @@ private:
   /// Underlying NT IoCompletionPort.
   ACE_HANDLE completion_port_;
 
-  // = Disallow these operations.
-  ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Message_Queue_NT &))
-  ACE_UNIMPLEMENTED_FUNC (ACE_Message_Queue_NT (const ACE_Message_Queue_NT &))
 };
 #endif /* ACE_WIN32 && ACE_HAS_WINNT4 != 0 */
 
diff --git a/ace/Method_Request.h b/ace/Method_Request.h
index fd6c8efb902..93adf76b8b7 100644
--- a/ace/Method_Request.h
+++ b/ace/Method_Request.h
@@ -86,13 +86,16 @@ public:
    */
   virtual int call (void) = 0;
 
+private:
+
+  /// Disallow copying and assignment.
+  ACE_Method_Request (const ACE_Method_Request &);
+  void operator= (const ACE_Method_Request &);
+
 protected:
   /// The priority of the request.
   unsigned long priority_;
 
-private:
-  ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Method_Request &))
-  ACE_UNIMPLEMENTED_FUNC (ACE_Method_Request (const ACE_Method_Request &))
 };
 
 ACE_END_VERSIONED_NAMESPACE_DECL
diff --git a/ace/Null_Mutex.h b/ace/Null_Mutex.h
index 2f912ebe2e5..8786b831280 100644
--- a/ace/Null_Mutex.h
+++ b/ace/Null_Mutex.h
@@ -149,9 +149,11 @@ public:
   void dump (void) const {}
 
 private:
-  // = Prevent assignment and initialization.
-  ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Guard<ACE_Null_Mutex> &))
-  ACE_UNIMPLEMENTED_FUNC (ACE_Guard (const ACE_Guard<ACE_Null_Mutex> &))
+
+  // Disallow copying and assignment.
+  ACE_Guard (const ACE_Guard<ACE_Null_Mutex> &);
+  void operator= (const ACE_Guard<ACE_Null_Mutex> &);
+
 };
 
 template <class ACE_LOCK>
diff --git a/ace/PI_Malloc.h b/ace/PI_Malloc.h
index 6908e77856e..5c5c0532d60 100644
--- a/ace/PI_Malloc.h
+++ b/ace/PI_Malloc.h
@@ -88,7 +88,10 @@ public:
     void dump (void) const;
 
   private:
-    ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Malloc_Header &))
+
+    // Disallow assignment.
+    void operator= (const ACE_Malloc_Header &);
+
   };
 
   /**
@@ -147,7 +150,9 @@ public:
     void dump (void) const;
 
   private:
-    ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Name_Node &))
+
+    // Disallow assignment.
+    void operator= (const ACE_Name_Node &);
   };
 
   /// Print out a bunch of size info for debugging.
@@ -194,7 +199,9 @@ public:
   void dump (void) const;
 
 private:
-  ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Control_Block &))
+
+  // Disallow assignment.
+  void operator= (const ACE_Control_Block &);
 };
 
 ACE_END_VERSIONED_NAMESPACE_DECL
diff --git a/ace/Process.h b/ace/Process.h
index b086c515bdd..8c0e55ac224 100644
--- a/ace/Process.h
+++ b/ace/Process.h
@@ -552,6 +552,12 @@ public:
   PROCESS_INFORMATION process_info (void);
 #endif /* ACE_WIN32 */
 
+private:
+
+  // Disallow copying and assignment since we don't support this (yet).
+  ACE_Process (const ACE_Process &);
+  void operator= (const ACE_Process &);
+
 protected:
   /// Set this process' <exit_code_>.  ACE_Process_Manager uses this
   /// method to set the <exit_code_> after successfully waiting for
@@ -571,9 +577,6 @@ protected:
   /// Handle duplicates made for the child process.
   ACE_Handle_Set dup_handles_;
 
-  // = Disallow copying and assignment since we don't support this (yet).
-  ACE_UNIMPLEMENTED_FUNC (ACE_Process (const ACE_Process &))
-  ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Process &))
 };
 
 
diff --git a/ace/Read_Buffer.h b/ace/Read_Buffer.h
index a28346518f2..74ad7d93ff9 100644
--- a/ace/Read_Buffer.h
+++ b/ace/Read_Buffer.h
@@ -92,6 +92,12 @@ public:
   void dump (void) const;
 
 private:
+
+  // Disallow copying and assignment...
+  void operator= (const ACE_Read_Buffer &);
+  ACE_Read_Buffer (const ACE_Read_Buffer &);
+
+private:
   /// Recursive helper method that does the work...
   char *rec_read (int term, int search, int replace);
 
@@ -111,9 +117,6 @@ private:
   /// Pointer to the allocator.
   ACE_Allocator *allocator_;
 
-  // = Disallow copying and assignment...
-  ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Read_Buffer &))
-  ACE_UNIMPLEMENTED_FUNC (ACE_Read_Buffer (const ACE_Read_Buffer &))
 };
 
 ACE_END_VERSIONED_NAMESPACE_DECL
diff --git a/ace/Select_Reactor.h b/ace/Select_Reactor.h
index b19ef6596b6..7cfe2f23a26 100644
--- a/ace/Select_Reactor.h
+++ b/ace/Select_Reactor.h
@@ -56,9 +56,10 @@ public:
   void dump (void) const {}
 
 private:
-  // = Prevent assignment and initialization.
-  ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Guard< ACE_Reactor_Token_T<ACE_Noop_Token> > &))
-  ACE_UNIMPLEMENTED_FUNC (ACE_Guard (const ACE_Guard< ACE_Reactor_Token_T<ACE_Noop_Token> > &))
+  // Disallow copying and assignment.
+  ACE_Guard (const ACE_Guard< ACE_Reactor_Token_T<ACE_Noop_Token> > &);
+  void operator= (const ACE_Guard< ACE_Reactor_Token_T<ACE_Noop_Token> > &);
+
 };
 #endif /* ACE_MT_SAFE && ACE_MT_SAFE == 0 */
 
diff --git a/ace/Stats.h b/ace/Stats.h
index cd4fe3e9448..f7f0d108823 100644
--- a/ace/Stats.h
+++ b/ace/Stats.h
@@ -81,6 +81,10 @@ public:
   void dump (void) const;
 
 private:
+
+  ACE_Stats_Value (void) {}
+
+private:
   /// The integer portion of the value.
   ACE_UINT32 whole_;
 
@@ -94,7 +98,6 @@ private:
    */
   u_int precision_;
 
-  ACE_UNIMPLEMENTED_FUNC (ACE_Stats_Value (void))
 };
 
 /**
diff --git a/ace/TP_Reactor.h b/ace/TP_Reactor.h
index 7aaf24f0942..37dee1a4b22 100644
--- a/ace/TP_Reactor.h
+++ b/ace/TP_Reactor.h
@@ -70,8 +70,9 @@ public:
   int dispatch_;
 
 private:
-  ACE_UNIMPLEMENTED_FUNC (ACE_EH_Dispatch_Info (const ACE_EH_Dispatch_Info &))
-  ACE_UNIMPLEMENTED_FUNC (ACE_EH_Dispatch_Info &operator= (const ACE_EH_Dispatch_Info &))
+  // Disallow copying and assignment.
+  ACE_EH_Dispatch_Info (const ACE_EH_Dispatch_Info &);
+  ACE_EH_Dispatch_Info &operator= (const ACE_EH_Dispatch_Info &);
 };
 
 
@@ -119,6 +120,11 @@ public:
 
 private:
 
+  // Disallow default construction.
+  ACE_TP_Token_Guard (void);
+
+private:
+
   /// The Select Reactor token.
   ACE_Select_Reactor_Token &token_;
 
@@ -128,9 +134,6 @@ private:
   /// vice-versa.
   int owner_;
 
-private:
-
-  ACE_UNIMPLEMENTED_FUNC (ACE_TP_Token_Guard (void))
 };
 
 /**
diff --git a/ace/Versioned_Namespace.h b/ace/Versioned_Namespace.h
index 32241642d83..32dcfe06051 100644
--- a/ace/Versioned_Namespace.h
+++ b/ace/Versioned_Namespace.h
@@ -18,14 +18,16 @@
 #define ACE_VERSIONED_NAMESPACE_H
 
 #ifndef ACE_CONFIG_LITE_H
-# error This header is only meant to be included by "ace/config-lite.h".
-#endif  /* !ACE_MAJOR_VERSION */
+# error This header is only meant to be included by or after "ace/config-lite.h".
+#endif  /* !ACE_CONFIG_LITE_H */
 
 
 #if defined (ACE_HAS_VERSIONED_NAMESPACE) && ACE_HAS_VERSIONED_NAMESPACE == 1 \
   && !(defined (_MSC_VER) && _MSC_VER <= 1200)
 
 # ifndef ACE_VERSIONED_NAMESPACE_NAME
+//#  include "ace/Version.h"
+
 // Preprocessor symbols will not be expanded if they are
 // concatenated.  Force the preprocessor to expand them during the
 // argument prescan by calling a macro that itself calls another that