Replaced ACE_ROA with ROA_Parameters, a GoF-style Singleton.

6 files changed, 102 insertions, 62 deletions

diff --git a/TAO/ChangeLog-98c b/TAO/ChangeLog-98c
index 8542e492c8b..d4c7084df78 100644
--- a/TAO/ChangeLog-98c
+++ b/TAO/ChangeLog-98c
@@ -1,3 +1,8 @@
+Mon Apr 14 13:45:54 1997  Chris Cleeland  <cleeland@cs.wustl.edu>
+
+	* roa.{hh,i,cpp},tcpoa.cpp,svr.cpp: Replaced ACE_ROA with
+ 	ROA_Parameters, which is a GoF-style singleton.
+
 Sun Apr 13 00:01:56 1997  Chris Cleeland  <cleeland@tango.cs.wustl.edu>
 
 	* roa.cpp: Fix continuation condition in ROA_Handler::svc()'s loop
diff --git a/TAO/IIOP/lib/roa.cpp b/TAO/IIOP/lib/roa.cpp
index 81be1337d7b..24a288727b8 100644
--- a/TAO/IIOP/lib/roa.cpp
+++ b/TAO/IIOP/lib/roa.cpp
@@ -2,17 +2,32 @@
 #include "tcpoa.hh"
 #include "debug.hh"
 
-int         ACE_ROA::end_reactor_event_loop_ = 0;
-ACE_Reactor ACE_ROA::theReactor;
-int         ACE_ROA::usingThreads_ = 0;
-unsigned int ACE_ROA::theThreadFlags = THR_NEW_LWP;
-void*       ACE_ROA::context_p = 0;
-ACE_ROA::UpcallFunc ACE_ROA::theUpcall = 0;
-ACE_ROA::ForwardFunc ACE_ROA::theForwarder = 0;
-TCP_OA_ptr     ACE_ROA::theOA = 0;
+ROA_Parameters* ROA_Parameters::_instance = 0;
+
+ROA_Parameters::ROA_Parameters()
+  : usingThreads_(0), threadFlags_(THR_NEW_LWP),
+    context_p_(0), reactor_(0),
+    upcall_(0), forwarder_(0), oa_(0)
+{
+}
+
+ROA_Parameters*
+ROA_Parameters::instance()
+{
+  if (_instance == 0)
+    {
+      _instance = new ROA_Parameters;
+    }
+  return _instance;
+}
 
 ROA_Handler::ROA_Handler()
 {
+  // Grab the singleton...at some later point in time
+  // we can provide an argumented CTOR so have per-instance
+  // parameters.
+  params_ = ROA_Parameters::instance();
+  ACE_ASSERT (params_ != 0);
 }
 
 int
@@ -23,9 +38,9 @@ ROA_Handler::open(void*)
   if (this->peer().get_remote_addr(addr) == -1)
     return -1;
 
-  if (ACE_ROA::usingThreads())
+  if (params_->usingThreads())
     {
-      if (activate(ACE_ROA::threadFlags()) == -1)
+      if (activate(params_->threadFlags()) == -1)
 	ACE_ERROR_RETURN ((LM_ERROR, "ROA_Handler unable to spawn a thread: %p\n", "spawn"), -1);
       else
 	ACE_DEBUG ((LM_DEBUG,
@@ -34,7 +49,7 @@ ROA_Handler::open(void*)
     }
   else
     {
-      if (ACE_ROA::reactor()->register_handler(this, ACE_Event_Handler::READ_MASK) == -1)
+      if (params_->reactor()->register_handler(this, ACE_Event_Handler::READ_MASK) == -1)
 	ACE_ERROR_RETURN ((LM_ERROR,
 			   "(%P|%t) can't register with reactor\n"), -1);
       else
@@ -75,10 +90,10 @@ ROA_Handler::handle_input(ACE_HANDLE fd)
   CORBA_Environment env;
   Dispatch_Context ctx;
 
-  ctx.skeleton = ACE_ROA::upcall();
-  ctx.context = ACE_ROA::context();
-  ctx.check_forward = ACE_ROA::forwarder();
-  ctx.oa = ACE_ROA::oa();
+  ctx.skeleton = params_->upcall();
+  ctx.context = params_->context();
+  ctx.check_forward = params_->forwarder();
+  ctx.oa = params_->oa();
   ctx.endpoint = peer();
 
 #ifdef	_POSIX_THREADS
@@ -88,7 +103,7 @@ ROA_Handler::handle_input(ACE_HANDLE fd)
   // Need to have a handle to a TCP_OA instance to make this call!!
   int ret;
 
-  switch(ACE_ROA::oa()->handle_message (ctx, env))
+  switch(params_->oa()->handle_message (ctx, env))
     {
     case 1:
     default:
diff --git a/TAO/IIOP/lib/roa.hh b/TAO/IIOP/lib/roa.hh
index 6b221d1a786..7ef0bf93f35 100644
--- a/TAO/IIOP/lib/roa.hh
+++ b/TAO/IIOP/lib/roa.hh
@@ -20,49 +20,55 @@ typedef TCP_OA* TCP_OA_ptr;
 
 // Provide a namespace/scope for singletons and other things
 // WARNING!  Not thread-safe yet!
-class ACE_ROA
+class ROA_Parameters
 {
 public:
   typedef TOA::dsi_handler UpcallFunc;
   typedef void (*ForwardFunc)(CORBA_OctetSeq&, CORBA_Object_ptr&, void*, CORBA_Environment&);
 
-  static ACE_Reactor* reactor();
+  static ROA_Parameters* instance();
 
-  static int usingThreads();
-  static void usingThreads(int i);
+  ACE_Reactor* reactor();
+  void reactor(ACE_Reactor* r);
+
+  int usingThreads();
+  void usingThreads(int i);
 
   // This should probably be replaced with fields that are a bit more
   // meaningful, but I need to dig through the code to find out what
   // "more meaningful" really means first.
-  static void* context();
-  static void context(void* p);
+  void* context();
+  void context(void* p);
 
   // In our first test case, this will always be set to tcp_oa_dispatcher
-  static UpcallFunc upcall();
-  static void upcall(UpcallFunc f);
+  UpcallFunc upcall();
+  void upcall(UpcallFunc f);
 
   // In our first test case, this will always be set to
   // tcp_oa_forwarder (even though we don't understand what the hell
   // it does!)
-  static ForwardFunc forwarder();
-  static void forwarder(ForwardFunc f);
+  ForwardFunc forwarder();
+  void forwarder(ForwardFunc f);
 
-  static TCP_OA_ptr oa();
-  static void oa(TCP_OA_ptr anOA);
+  TCP_OA_ptr oa();
+  void oa(TCP_OA_ptr anOA);
 
-  static unsigned int threadFlags();
-  static void threadFlags(unsigned int f);
+  unsigned int threadFlags();
+  void threadFlags(unsigned int f);
 
-  static int end_reactor_event_loop_;
+protected:
+  ROA_Parameters();
 
 private:
-  static ACE_Reactor theReactor;
-  static int usingThreads_;
-  static void* context_p;
-  static UpcallFunc theUpcall;
-  static ForwardFunc theForwarder;
-  static TCP_OA_ptr theOA;
-  static unsigned int theThreadFlags;
+  static ROA_Parameters* _instance;
+
+  ACE_Reactor* reactor_;
+  int usingThreads_;
+  void* context_p_;
+  UpcallFunc upcall_;
+  ForwardFunc forwarder_;
+  TCP_OA_ptr oa_;
+  unsigned int threadFlags_;
 };
 
 class ROA_Handler : public ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>
@@ -71,9 +77,15 @@ public:
   ROA_Handler();
   virtual int open(void*);
   virtual int svc(void);
+
+  ROA_Parameters* params();
+  void params(ROA_Parameters* p);
+
 protected:
   virtual int handle_input(ACE_HANDLE = ACE_INVALID_HANDLE);
   virtual int handle_close(ACE_HANDLE, ACE_Reactor_Mask);
+
+  ROA_Parameters* params_;
 };
 
 typedef ACE_Acceptor<ROA_Handler, ACE_SOCK_ACCEPTOR> ROA_Acceptor;
diff --git a/TAO/IIOP/lib/roa.i b/TAO/IIOP/lib/roa.i
index 2c8c8b2716a..dd3fc233d31 100644
--- a/TAO/IIOP/lib/roa.i
+++ b/TAO/IIOP/lib/roa.i
@@ -1,19 +1,24 @@
-ACE_INLINE ACE_Reactor* ACE_ROA::reactor() {  return &theReactor; }
+ACE_INLINE void ROA_Parameters::reactor(ACE_Reactor* i) { reactor_ = i; }
+ACE_INLINE ACE_Reactor*  ROA_Parameters::reactor()
+{
+  if (reactor_ == 0) reactor_ = ACE_Service_Config::reactor();
+  return reactor_;
+}
 
-ACE_INLINE int  ACE_ROA::usingThreads()      { return usingThreads_; }
-ACE_INLINE void ACE_ROA::usingThreads(int i) { usingThreads_ = i; }
+ACE_INLINE int  ROA_Parameters::usingThreads()      { return usingThreads_; }
+ACE_INLINE void ROA_Parameters::usingThreads(int i) { usingThreads_ = i; }
 
-ACE_INLINE void* ACE_ROA::context()        { return context_p; }
-ACE_INLINE void  ACE_ROA::context(void* p) { context_p = p; }
+ACE_INLINE void* ROA_Parameters::context()        { return context_p_; }
+ACE_INLINE void  ROA_Parameters::context(void* p) { context_p_ = p; }
 
-ACE_INLINE ACE_ROA::UpcallFunc ACE_ROA::upcall() { return theUpcall; }
-ACE_INLINE void ACE_ROA::upcall(ACE_ROA::UpcallFunc f) { theUpcall = f; }
+ACE_INLINE ROA_Parameters::UpcallFunc ROA_Parameters::upcall() { return upcall_; }
+ACE_INLINE void ROA_Parameters::upcall(ROA_Parameters::UpcallFunc f) { upcall_ = f; }
 
-ACE_INLINE ACE_ROA::ForwardFunc ACE_ROA::forwarder() { return theForwarder; }
-ACE_INLINE void ACE_ROA::forwarder(ACE_ROA::ForwardFunc f) { theForwarder = f; }
+ACE_INLINE ROA_Parameters::ForwardFunc ROA_Parameters::forwarder() { return forwarder_; }
+ACE_INLINE void ROA_Parameters::forwarder(ROA_Parameters::ForwardFunc f) { forwarder_ = f; }
 
-ACE_INLINE TCP_OA_ptr ACE_ROA::oa() { return theOA; }
-ACE_INLINE void ACE_ROA::oa(TCP_OA_ptr anOA) { theOA = anOA; }
+ACE_INLINE TCP_OA_ptr ROA_Parameters::oa() { return oa_; }
+ACE_INLINE void ROA_Parameters::oa(TCP_OA_ptr anOA) { oa_ = anOA; }
 
-ACE_INLINE unsigned int ACE_ROA::threadFlags() { return theThreadFlags; }
-ACE_INLINE void ACE_ROA::threadFlags(unsigned int f) { theThreadFlags = f; }
+ACE_INLINE unsigned int ROA_Parameters::threadFlags() { return threadFlags_; }
+ACE_INLINE void ROA_Parameters::threadFlags(unsigned int f) { threadFlags_ = f; }
diff --git a/TAO/IIOP/lib/tcpoa.cpp b/TAO/IIOP/lib/tcpoa.cpp
index 67bf156ca86..edb824b60eb 100644
--- a/TAO/IIOP/lib/tcpoa.cpp
+++ b/TAO/IIOP/lib/tcpoa.cpp
@@ -213,17 +213,19 @@ TCP_OA::TCP_OA (CORBA_ORB_ptr owning_orb,
     _orb(owning_orb), call_count(0), skeleton(0)
 {
   assert (the_oa == 0); 
+  
+  ROA_Parameters* p = ROA_Parameters::instance();
 
   //
   // Initialize the endpoint ... or try!
   //
-  if (clientAcceptor_.open(rendesvous, ACE_ROA::reactor()) == -1)
+  if (clientAcceptor_.open(rendesvous, p->reactor()) == -1)
     {
       // XXXCJC Need to return an error somehow!!
     }
 
-  else if (ACE_ROA::reactor()->register_handler(&clientAcceptor_,
-					    ACE_Event_Handler::ACCEPT_MASK) == -1)
+  else if (p->reactor()->register_handler(&clientAcceptor_,
+					  ACE_Event_Handler::ACCEPT_MASK) == -1)
     {
       // XXXCJC Need to return an error somehow!!
     }
diff --git a/TAO/IIOP/test/svr.cpp b/TAO/IIOP/test/svr.cpp
index 73b9ab247e1..c65ecd23239 100644
--- a/TAO/IIOP/test/svr.cpp
+++ b/TAO/IIOP/test/svr.cpp
@@ -224,6 +224,7 @@ main (
   CORBA_Boolean	do_threads = CORBA_B_FALSE;
   CORBA_String	key = (CORBA_String) "key0";
   ACE_INET_Addr svraddr;
+  ROA_Parameters* params = ROA_Parameters::instance();
   char		*oa_name = 0;
   char		*orb_name = "internet";
   int			idle = -1;
@@ -260,8 +261,8 @@ main (
       oa_name = opts.optarg;
       continue;
 	
-    case 't':			// create thread-per-request
-      ACE_ROA::usingThreads(1);
+    case 't':			// create thread-per-connection
+      params->usingThreads(1);
       continue;
 
       // XXX set debug filters ...
@@ -301,7 +302,7 @@ main (
     return 1;
   }
   // Register the OA with ACE_ROA
-  ACE_ROA::oa(oa_ptr);		// Should this be done in TCP_OA's CTOR?
+  params->oa(oa_ptr);		// Should this be done in TCP_OA's CTOR?
 
 #if 0
   // This is the old call and syntax
@@ -406,13 +407,13 @@ main (
   int terminationStatus = 0;
 #if defined(USE_ACE_EVENT_HANDLING)
   // Set the callbacks for our implementation (cheesy!!!)
-  ACE_ROA::upcall(tcpoa_dispatch);
-  ACE_ROA::forwarder(fwd_ref ? tcpoa_forwarder : 0);
-  ACE_ROA::context(&obj_key);
+  params->upcall(tcpoa_dispatch);
+  params->forwarder(fwd_ref ? tcpoa_forwarder : 0);
+  params->context(&obj_key);
 
-  while (ACE_ROA::end_reactor_event_loop_ == 0)
+  while (1)
     {
-      int result = ACE_ROA::reactor()->handle_events ();
+      int result = params->reactor()->handle_events ();
 
       if (result == -1)
 	{