Made Service_Type_Repository a non-template class.

Renamed Trader.* -> Trader_T.*
Fixed other little bugs whose nature eludes me at the moment.

12 files changed, 166 insertions, 99 deletions

diff --git a/TAO/orbsvcs/orbsvcs/Trader/Attributes.cpp b/TAO/orbsvcs/orbsvcs/Trader/Attributes.cpp
index 8a352b0030c..f720f008ceb 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Attributes.cpp
+++ b/TAO/orbsvcs/orbsvcs/Trader/Attributes.cpp
@@ -72,7 +72,7 @@ TAO_Support_Attributes_Impl::type_repos (void) const
 {
   ACE_READ_GUARD_RETURN (ACE_Lock, ace_mon, this->trader_.lock (),
 			 CosTrading::TypeRepository::_nil ());
-  return this->type_repos_->_duplicate (type_repos_);
+  return this->type_repos_;
 }
   
 void
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Attributes.h b/TAO/orbsvcs/orbsvcs/Trader/Attributes.h
index e6b35064996..68e71880d72 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Attributes.h
+++ b/TAO/orbsvcs/orbsvcs/Trader/Attributes.h
@@ -64,7 +64,7 @@ private:
   CORBA::Boolean supports_proxy_offers_;
   // Indicator of whether the trader supports proxy offers.
 
-  CosTrading::TypeRepository_ptr type_repos_;
+  CORBA::Object_var type_repos_;
   // A reference to the TypeRepostitory used by the trader.
 };
 
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Lookup.cpp b/TAO/orbsvcs/orbsvcs/Trader/Lookup.cpp
index c3315ea9e40..771db950890 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Lookup.cpp
+++ b/TAO/orbsvcs/orbsvcs/Trader/Lookup.cpp
@@ -324,16 +324,17 @@ lookup_all_subtypes (const char* type,
   // proceeds until all of the subtypes for the original class have
   // been located and their offers considered, or we've exhausted the
   // cardinality constraints.
-  
-  list<char*> sub_types, unconsidered_types;
+
+  string type_string (type);
+  TYPE_LIST sub_types, unconsidered_types;
   CosTradingRepos::ServiceTypeRepository::SpecifiedServiceTypes sst;
   TYPE_NAME_SEQ all_types (service_type_map.list_all_types ());
   
   // All types save the supertype are initially unconsidered.
-  sub_types.push_back ((char *) type);
+  sub_types.push_back (type_string);
   for (int i = all_types->length () - 1; i >= 0; i--)
-    unconsidered_types.push_back ((char*)((const char*) all_types[i]));
-  unconsidered_types.remove ((char *) type);
+    unconsidered_types.push_back (string (all_types[i]));
+  unconsidered_types.remove (type_string);
 
   // Iterate over the remaining subtypes to locate their subtypes.
   // We could meet our cardinality constraints prior searching all
@@ -341,7 +342,7 @@ lookup_all_subtypes (const char* type,
   while (! sub_types.empty () && offer_filter.ok_to_consider_more ())  
   {
     // For each potential supertype, iterate over the remaining types.
-    const char* super_type = sub_types.front ();
+    const char* super_type = sub_types.front ().data ();
     sub_types.pop_front ();
     for (int j = unconsidered_types.size () - 1;
 	 j >= 0 && offer_filter.ok_to_consider_more ();
@@ -349,12 +350,12 @@ lookup_all_subtypes (const char* type,
       {
 	TYPE_STRUCT type_struct;
 	CORBA::Boolean is_sub_type = 0;
-	char* type_name = unconsidered_types.front ();
+	string type_name = unconsidered_types.front ();
 	unconsidered_types.pop_front ();
 	
 	TAO_TRY
 	  {
-	    type_struct = rep->describe_type (type_name, TAO_TRY_ENV);
+	    type_struct = rep->describe_type (type_name.data (), TAO_TRY_ENV);
 	  }
 	TAO_CATCHANY
 	  {
@@ -377,7 +378,7 @@ lookup_all_subtypes (const char* type,
 	  {
 	    // Otherwise, perform a constraint match on the type, and
 	    // add it to the queue of potential supertypes.
-	    this->lookup_one_type (type_name,
+	    this->lookup_one_type (type_name.data (),
 				   service_type_map,
 				   constr_inter,
 				   pref_inter,
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Lookup.h b/TAO/orbsvcs/orbsvcs/Trader/Lookup.h
index a1703b09762..f7fd3f14b1a 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Lookup.h
+++ b/TAO/orbsvcs/orbsvcs/Trader/Lookup.h
@@ -21,11 +21,12 @@
 
 #include "Policies.h"
 #include "Offer_Filter.h"
-#include "Property_Filter.h"
 #include "Offer_Iterator.h"
 #include "Constraint_Interpreter.h"
 #include "Preference_Interpreter.h"
 
+#include <list>
+
 template<class TRADER>
 class TAO_Lookup :
   public TAO_Trader_Components<POA_CosTrading::Lookup>,
@@ -155,7 +156,8 @@ private:
   typedef TRADER::LOCAL_OFFER_ITER LOCAL_OFFER_ITER;
   typedef TRADER::SERVICE_TYPE_MAP SERVICE_TYPE_MAP;
   typedef pair<CosTrading::OfferId, CosTrading::Offer*> OFFER;
-  typedef deque <OFFER> LOOKUP_OFFER_LIST;
+  typedef deque<OFFER> LOOKUP_OFFER_LIST;
+  typedef list<string> TYPE_LIST;
 
   TAO_Offer_Iterator*
     create_offer_iterator (const char *type,
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Monitor.h b/TAO/orbsvcs/orbsvcs/Trader/Monitor.h
index 4fa35a45d6a..21741ca7bda 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Monitor.h
+++ b/TAO/orbsvcs/orbsvcs/Trader/Monitor.h
@@ -41,22 +41,45 @@ class TAO_Monitor : public TYPE
 public:
   
   typedef TAO_LOCK LOCK_TYPE;
+
+  TAO_Monitor (void)
+    : delete_ (1)
+    {
+      ACE_NEW (this->lock_, TAO_LOCK);
+    }
+  
+  TAO_Monitor (const TAO_Monitor& monitor)
+    {
+      // Assume control of their lock.
+      TAO_Monitor* mon = (TAO_Monitor*)&monitor;
+      mon->delete_ = 0;
+      this->delete_ = 1;
+      this->lock_ = mon->lock_;
+    }
+
+  ~TAO_Monitor (void)
+    {
+      if (this->delete_)
+	delete this->lock_;
+    }
   
   // Return a reference to the lock that I use.
   TAO_LOCK &lock (void)
   {
-    return this->lock_;
+    return *this->lock_;
   }
 
   // Return a reference to the lock that I use.
   const TAO_LOCK &lock (void) const
   {
-    return this->lock_;
+    return *this->lock_;
   }
 
 protected:
 
-  TAO_LOCK lock_;
+  int delete_;
+  
+  TAO_LOCK* lock_;
   // Lock used to monitor the object.
 };
 
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Register.cpp b/TAO/orbsvcs/orbsvcs/Trader/Register.cpp
index f0c19aa7de9..c8f3f30ee17 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Register.cpp
+++ b/TAO/orbsvcs/orbsvcs/Trader/Register.cpp
@@ -94,7 +94,7 @@ TAO_Register<TRADER>::export (CORBA::Object_ptr reference,
   offer.reference = (reference->_duplicate (reference));
   offer.properties = properties;
   
-  // Inser the offer into the underlying type map.
+  // Insert the offer into the underlying type map.
   CosTrading::OfferId id = service_type_map.insert_offer (type, offer);
   
   if (id == 0)
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Service_Type_Repository.cpp b/TAO/orbsvcs/orbsvcs/Trader/Service_Type_Repository.cpp
index 1e808f6362e..9635a6efe7a 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Service_Type_Repository.cpp
+++ b/TAO/orbsvcs/orbsvcs/Trader/Service_Type_Repository.cpp
@@ -15,46 +15,42 @@
 // 
 // ========================================================================
 
-#if !defined (TAO_SERVICE_TYPE_REPOSITORY_C)
-#define TAO_SERVICE_TYPE_REPOSITORY_C
-
 #include "Locking.h"
 #include "Service_Type_Repository.h"
 
-template <class MAP_LOCK_TYPE>
-const char* TAO_Service_Type_Repository<MAP_LOCK_TYPE>::
-NAME = "Type_Repository";
-
-template <class MAP_LOCK_TYPE>
-TAO_Service_Type_Repository<MAP_LOCK_TYPE>::
-TAO_Service_Type_Repository (void)
+TAO_Service_Type_Repository::
+TAO_Service_Type_Repository (ACE_Lock* lock)
+  : lock_ (lock)
 {
   incarnation_.low = 0;
   incarnation_.high = 0;
+
+  // If a lock wasn't provided, let's assume the user doesn't want any
+  // kind of lock at all.
+  if (this->lock_ == 0)
+    ACE_NEW (this->lock_, ACE_Lock_Adapter<ACE_Null_Mutex> ());
 }
 
-template <class MAP_LOCK_TYPE>
-TAO_Service_Type_Repository<MAP_LOCK_TYPE>::
+
+TAO_Service_Type_Repository::
 ~TAO_Service_Type_Repository (void)
 {
+  delete this->lock_;
 }
 
-template <class MAP_LOCK_TYPE>
+
 SERVICE_TYPE_REPOS::IncarnationNumber 
-TAO_Service_Type_Repository<MAP_LOCK_TYPE>::
+TAO_Service_Type_Repository::
 incarnation (CORBA::Environment& _env)
 {
   SERVICE_TYPE_REPOS::IncarnationNumber inc_num;
-  TAO_READ_GUARD_RETURN (MAP_LOCK_TYPE, 
-			 ace_mon, 
-			 this->type_map_.lock (),
-			 inc_num);
+  TAO_READ_GUARD_RETURN (ACE_Lock, ace_mon, *this->lock_, inc_num);
   return incarnation_;
 }
 
-template <class MAP_LOCK_TYPE>
+
 SERVICE_TYPE_REPOS::IncarnationNumber 
-TAO_Service_Type_Repository<MAP_LOCK_TYPE>::
+TAO_Service_Type_Repository::
 add_type (const char * name, 
 	  const char * if_name, 
 	  const SERVICE_TYPE_REPOS::PropStructSeq& props, 
@@ -76,10 +72,7 @@ add_type (const char * name,
   SERVICE_TYPE_MAP::iterator type_iterator;
   SERVICE_TYPE_REPOS::IncarnationNumber inc_num;
   
-  TAO_WRITE_GUARD_RETURN (MAP_LOCK_TYPE, 
-			  ace_mon, 
-			  this->type_map_.lock (),
-			  inc_num);
+  TAO_WRITE_GUARD_RETURN (ACE_Lock, ace_mon, *this->lock_, inc_num);
 
   // make sure Type name is valid
   if (! TAO_Trader_Base::is_valid_identifier_name (name))
@@ -137,9 +130,9 @@ add_type (const char * name,
   return this->type_map_[name].type_info_.incarnation;
 }
 
-template <class MAP_LOCK_TYPE>
+
 void 
-TAO_Service_Type_Repository<MAP_LOCK_TYPE>::
+TAO_Service_Type_Repository::
 remove_type (const char * name,
 	     CORBA::Environment& _env)
   TAO_THROW_SPEC ((CORBA::SystemException, 
@@ -147,12 +140,13 @@ remove_type (const char * name,
 		  CosTrading::UnknownServiceType, 
 		  SERVICE_TYPE_REPOS::HasSubTypes))
 {
+  ACE_DEBUG ((LM_DEBUG, "TAO_Service_Type_Repository::remove_type (%s)\n",
+	      name));
+	      
   if (! TAO_Trader_Base::is_valid_identifier_name (name))
     TAO_THROW (CosTrading::IllegalServiceType (name));
 
-  TAO_WRITE_GUARD (MAP_LOCK_TYPE, 
-		   ace_mon, 
-		   this->type_map_.lock ());
+  TAO_WRITE_GUARD (ACE_Lock, ace_mon, *this->lock_);
 
   // check if the type exists.
   SERVICE_TYPE_MAP::iterator type_iterator = this->type_map_.find (name);
@@ -185,16 +179,16 @@ remove_type (const char * name,
   this->type_map_.erase (type_iterator);
 }
            
-template <class MAP_LOCK_TYPE>
+
 SERVICE_TYPE_REPOS::ServiceTypeNameSeq* 
-TAO_Service_Type_Repository<MAP_LOCK_TYPE>::
+TAO_Service_Type_Repository::
 list_types (const SERVICE_TYPE_REPOS::SpecifiedServiceTypes& which_types,
 	    CORBA::Environment& _env)
   TAO_THROW_SPEC ((CORBA::SystemException))
 {
-  TAO_READ_GUARD_RETURN (MAP_LOCK_TYPE, 
+  TAO_READ_GUARD_RETURN (ACE_Lock, 
 			 ace_mon, 
-			 this->type_map_.lock (),
+			 *this->lock_,
 			 (SERVICE_TYPE_REPOS::ServiceTypeNameSeq*) 0);
   
   SERVICE_TYPE_REPOS::ServiceTypeNameSeq_ptr result =
@@ -235,9 +229,9 @@ list_types (const SERVICE_TYPE_REPOS::SpecifiedServiceTypes& which_types,
 }
 
            
-template <class MAP_LOCK_TYPE>
+
 SERVICE_TYPE_REPOS::TypeStruct*
-TAO_Service_Type_Repository<MAP_LOCK_TYPE>::
+TAO_Service_Type_Repository::
 describe_type (const char * name,
 	       CORBA::Environment& _env) 
   TAO_THROW_SPEC ((CORBA::SystemException,
@@ -248,9 +242,9 @@ describe_type (const char * name,
     TAO_THROW_RETURN (CosTrading::IllegalServiceType (name),
 		      (SERVICE_TYPE_REPOS::TypeStruct*) 0);
 
-  TAO_READ_GUARD_RETURN (MAP_LOCK_TYPE, 
+  TAO_READ_GUARD_RETURN (ACE_Lock, 
 			 ace_mon, 
-			 this->type_map_.lock (),
+			 *this->lock_,
 			 (SERVICE_TYPE_REPOS::TypeStruct*) 0);
 
   // make sure the type exists.
@@ -268,9 +262,9 @@ describe_type (const char * name,
   return descr;
 }
        
-template <class MAP_LOCK_TYPE>
+
 SERVICE_TYPE_REPOS::TypeStruct* 
-TAO_Service_Type_Repository<MAP_LOCK_TYPE>::
+TAO_Service_Type_Repository::
 fully_describe_type (const char * name,
 		     CORBA::Environment& _env) 
   TAO_THROW_SPEC ((CORBA::SystemException,
@@ -281,9 +275,9 @@ fully_describe_type (const char * name,
     TAO_THROW_RETURN (CosTrading::IllegalServiceType (name),
 		      (SERVICE_TYPE_REPOS::TypeStruct*) 0);
   
-  TAO_READ_GUARD_RETURN (MAP_LOCK_TYPE, 
+  TAO_READ_GUARD_RETURN (ACE_Lock, 
 			 ace_mon, 
-			 this->type_map_.lock (),
+			 *this->lock_,
 			 (SERVICE_TYPE_REPOS::TypeStruct*) 0);
 
   // make sure the type exists.
@@ -309,9 +303,9 @@ fully_describe_type (const char * name,
   return descr;  
 }
 
-template <class MAP_LOCK_TYPE>
+
 void 
-TAO_Service_Type_Repository<MAP_LOCK_TYPE>::
+TAO_Service_Type_Repository::
 mask_type (const char * name,
 	   CORBA::Environment& _env)
   TAO_THROW_SPEC ((CORBA::SystemException, 
@@ -322,9 +316,7 @@ mask_type (const char * name,
   if (! TAO_Trader_Base::is_valid_identifier_name (name))
     TAO_THROW (CosTrading::IllegalServiceType (name));
 
-  TAO_WRITE_GUARD (MAP_LOCK_TYPE, 
-		   ace_mon, 
-		   this->type_map_.lock ());
+  TAO_WRITE_GUARD (ACE_Lock, ace_mon, *this->lock_);
 
   // make sure the type exists.
   SERVICE_TYPE_MAP::iterator type_iterator = this->type_map_.find (name);
@@ -340,9 +332,9 @@ mask_type (const char * name,
     mask = 1;
 }
        
-template <class MAP_LOCK_TYPE>
+
 void 
-TAO_Service_Type_Repository<MAP_LOCK_TYPE>::
+TAO_Service_Type_Repository::
 unmask_type (const char * name,
 	     CORBA::Environment& _env)
   TAO_THROW_SPEC ((CORBA::SystemException,
@@ -353,9 +345,7 @@ unmask_type (const char * name,
   if (! TAO_Trader_Base::is_valid_identifier_name (name))
     TAO_THROW (CosTrading::IllegalServiceType (name));
 
-  TAO_WRITE_GUARD (MAP_LOCK_TYPE, 
-		   ace_mon, 
-		   this->type_map_.lock ());
+  TAO_WRITE_GUARD (ACE_Lock, ace_mon, *this->lock_);
 
   // make sure the type exists.
   SERVICE_TYPE_MAP::iterator type_iterator = this->type_map_.find (name);
@@ -371,8 +361,8 @@ unmask_type (const char * name,
     mask = 0;
 }
 
-template <class MAP_LOCK_TYPE> void
-TAO_Service_Type_Repository<MAP_LOCK_TYPE>::
+ void
+TAO_Service_Type_Repository::
 validate_properties (const SERVICE_TYPE_REPOS::PropStructSeq& props,
 		     PROP_MAP& prop_map,
 		     CORBA::Environment& _env)
@@ -397,8 +387,8 @@ validate_properties (const SERVICE_TYPE_REPOS::PropStructSeq& props,
     }
 }
 
-template <class MAP_LOCK_TYPE> void
-TAO_Service_Type_Repository<MAP_LOCK_TYPE>::
+ void
+TAO_Service_Type_Repository::
 validate_supertypes (const SERVICE_TYPE_REPOS::ServiceTypeNameSeq& super_types,
 		     SUPER_TYPE_MAP& super_map,
 		     CORBA::Environment& _env)
@@ -427,8 +417,8 @@ validate_supertypes (const SERVICE_TYPE_REPOS::ServiceTypeNameSeq& super_types,
     }
 }
 
-template <class MAP_LOCK_TYPE> void
-TAO_Service_Type_Repository<MAP_LOCK_TYPE>
+void
+TAO_Service_Type_Repository
 ::validate_inheritance (PROP_MAP& prop_map,
 			SUPER_TYPE_MAP& super_map,
 			CORBA::Environment& _env)
@@ -478,8 +468,8 @@ TAO_Service_Type_Repository<MAP_LOCK_TYPE>
     }
 }
 
-template <class MAP_LOCK_TYPE> void
-TAO_Service_Type_Repository<MAP_LOCK_TYPE>::
+void
+TAO_Service_Type_Repository::
 update_type_map (const char* name,
 		 SERVICE_TYPE_REPOS::TypeStruct& info,
 		 PROP_MAP& prop_map,
@@ -536,4 +526,3 @@ operator> (const SERVICE_TYPE_REPOS::IncarnationNumber &l,
   return (r < l);
 }
 
-#endif /* TAO_SERVICE_TYPE_REPOSITORY_C */
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Service_Type_Repository.h b/TAO/orbsvcs/orbsvcs/Trader/Service_Type_Repository.h
index 136df0e611f..fef9457923e 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Service_Type_Repository.h
+++ b/TAO/orbsvcs/orbsvcs/Trader/Service_Type_Repository.h
@@ -24,7 +24,6 @@
 
 typedef CosTradingRepos::ServiceTypeRepository SERVICE_TYPE_REPOS;
 
-template <class MAP_LOCK_TYPE>
 class TAO_Service_Type_Repository :
   public POA_CosTradingRepos::ServiceTypeRepository
   //
@@ -34,8 +33,12 @@ class TAO_Service_Type_Repository :
 {
 public:
   
-  TAO_Service_Type_Repository (void);
-
+  TAO_Service_Type_Repository (ACE_Lock* lock = 0);
+  // Parameterize the Service_Type_Repository with a lock to serialize
+  // access to the type repository map. A reader/writer lock is
+  // probably best. The Service_Type_Repository assumes control of the 
+  // lock.
+  
   ~TAO_Service_Type_Repository (void);
   
   virtual SERVICE_TYPE_REPOS::IncarnationNumber 
@@ -202,8 +205,6 @@ public:
   // exception is raised. 
   // END SPEC
 
-  static const char * NAME;
-
 private:
   
   struct Type_Info {
@@ -221,14 +222,8 @@ private:
     // names of subtypes.
   };
   
-  typedef map< string, Type_Info, less <string> > TYPE_MAP;
-  typedef TYPE_MAP::iterator TYPE_MAP_ITER;
-  
-  typedef TAO_Monitor
-    <
-    TYPE_MAP,
-    MAP_LOCK_TYPE
-    > SERVICE_TYPE_MAP;
+  typedef map< string, Type_Info, less <string> > SERVICE_TYPE_MAP;
+  typedef SERVICE_TYPE_MAP::iterator SERVICE_TYPE_ITERATOR;
   
   typedef map
     <
@@ -240,10 +235,10 @@ private:
   typedef map
     <
     string,
-    TYPE_MAP_ITER,
+    SERVICE_TYPE_MAP::iterator,
     less < string >
     > SUPER_TYPE_MAP;
-
+  
   void validate_properties (const SERVICE_TYPE_REPOS::PropStructSeq& props,
 			    PROP_MAP& prop_map,
 			    CORBA::Environment& _env)
@@ -279,6 +274,9 @@ private:
 			SUPER_TYPE_MAP& super_map);
   // Update the type map with the information contained in the
   // TypeStruct, prop_map, and super_map.
+
+  ACE_Lock* lock_;
+  // Lock with which to serialize access to the service type map.
   
   SERVICE_TYPE_MAP type_map_;
   // Stores information for each service type in the repository.
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Trader_Base.cpp b/TAO/orbsvcs/orbsvcs/Trader/Trader_Base.cpp
index c5ad6ec9e82..9391337d7aa 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Trader_Base.cpp
+++ b/TAO/orbsvcs/orbsvcs/Trader/Trader_Base.cpp
@@ -80,9 +80,12 @@ TAO_Trader_Base::trading_components (void) const
 CORBA::Boolean
 TAO_Trader_Base::is_valid_identifier_name (const char* ident)
 {
-  int return_value = 0,
-    length = ACE_OS::strlen (ident);
+  int return_value = CORBA::B_FALSE;
 
+  if (ident == 0)
+    return return_value;
+  
+  int length = ACE_OS::strlen (ident);
   if (length >= 1 && isalpha (ident[0]))
     {
       return_value = 1;
@@ -98,3 +101,34 @@ TAO_Trader_Base::is_valid_identifier_name (const char* ident)
 
   return return_value;
 }
+
+#include "Trader_T.h"
+
+TAO_Trader_Factory::TAO_TRADER*
+TAO_Trader_Factory::TAO_create_linked_trader (void)
+{
+  TAO_TRADER::Trader_Components linked_trader =
+    (TAO_TRADER::Trader_Components)
+    (TAO_TRADER::LOOKUP |
+     TAO_TRADER::REGISTER |
+     TAO_TRADER::ADMIN |
+     TAO_TRADER::LINK);
+  return new TAO_TRADER (linked_trader);
+}
+
+#ifdef ACE_HAS_THREADS
+
+TAO_Trader_Factory::TAO_MT_TRADER*
+TAO_Trader_Factory::TAO_MT_create_linked_trader (void)
+{
+  TAO_MT_TRADER::Trader_Components linked_trader =
+    (TAO_MT_TRADER::Trader_Components)
+    (TAO_MT_TRADER::LOOKUP |
+     TAO_MT_TRADER::REGISTER |
+     TAO_MT_TRADER::ADMIN |
+     TAO_MT_TRADER::LINK);
+  return new TAO_MT_TRADER (linked_trader);
+}
+
+#endif /* ACE_HAS_THREADS */
+
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Trader_Base.h b/TAO/orbsvcs/orbsvcs/Trader/Trader_Base.h
index 6838ba03b1b..b6f4ef399f7 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Trader_Base.h
+++ b/TAO/orbsvcs/orbsvcs/Trader/Trader_Base.h
@@ -24,6 +24,26 @@
 
 #include "Attributes.h"
 
+// Forward Declaration
+template <class TRADER_LOCK_TYPE, MAP_LOCK_TYPE>
+class TAO_Trader;
+
+// Cludge to avoid template instantiation in the executable.
+class TAO_Trader_Factory
+{
+public:
+  
+  typedef TAO_Trader<ACE_Null_Mutex, ACE_Null_Mutex> TAO_TRADER;  
+  static TAO_TRADER* TAO_create_linked_trader (void);
+  
+#ifdef ACE_HAS_THREADS
+  
+  typedef TAO_Trader<ACE_Thread_Mutex, ACE_RW_Mutex> TAO_MT_TRADER;
+  static TAO_MT_TRADER* TAO_MT_create_linked_trader (void);
+  
+#endif /* ACE_HAS_THREADS */
+};
+
 class TAO_Export TAO_Trader_Base
   //
   // = TITLE
@@ -88,4 +108,5 @@ protected:
   // Stores and allows access/modification of trader's link attributes.
 };
 
+
 #endif /* TAO_TRADER_BASE_H */
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Trader.cpp b/TAO/orbsvcs/orbsvcs/Trader/Trader_T.cpp
index c6dd48d12eb..7ac0533eeb5 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Trader.cpp
+++ b/TAO/orbsvcs/orbsvcs/Trader/Trader_T.cpp
@@ -38,25 +38,25 @@ TAO_Trader<TRADER_LOCK_TYPE, MAP_LOCK_TYPE>::TAO_Trader (Trader_Components compo
       this->trading_components ().lookup_if (lookup->_this (env));
       this->ifs_[LOOKUP_IF] = lookup;
     }
-  else if (ACE_BIT_ENABLED (components, REGISTER))
+  if (ACE_BIT_ENABLED (components, REGISTER))
     {
       TAO_Register<TRADER_SELF>* reg = new TAO_Register<TRADER_SELF> (*this);
       this->trading_components ().register_if (reg->_this (env));
       this->ifs_[REGISTER_IF] = reg;
     }
-  else if (ACE_BIT_ENABLED (components, ADMIN))
+  if (ACE_BIT_ENABLED (components, ADMIN))
     {
       TAO_Admin<TRADER_SELF>* admin = new TAO_Admin<TRADER_SELF> (*this);
       this->trading_components ().admin_if (admin->_this (env));
       this->ifs_[ADMIN_IF] = admin;
     }
-  else if (ACE_BIT_ENABLED (components, PROXY))
+  if (ACE_BIT_ENABLED (components, PROXY))
     {
       TAO_Proxy<TRADER_SELF>* proxy = new TAO_Proxy<TRADER_SELF> (*this);
       this->trading_components ().proxy_if (proxy->_this (env));
       this->ifs_[PROXY_IF] = proxy;
     }
-  else if (ACE_BIT_ENABLED (components, LINK))
+  if (ACE_BIT_ENABLED (components, LINK))
     {
       TAO_Link<TRADER_SELF, MAP_LOCK_TYPE>* link =
 	new TAO_Link<TRADER_SELF, MAP_LOCK_TYPE> (*this);
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Trader.h b/TAO/orbsvcs/orbsvcs/Trader/Trader_T.h
index f6347dd09c0..f7938d097fd 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Trader.h
+++ b/TAO/orbsvcs/orbsvcs/Trader/Trader_T.h
@@ -95,7 +95,6 @@ protected:
   PortableServer::ServantBase* ifs_[5];
 };
 
-
 #if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
 #include "Trader.cpp"
 #endif  /* ACE_TEMPLATES_REQUIRE_SOURCE */