TAO/tao/Adapter_Registry.cpp

   1 #include "tao/Object.h"
   2 #include "tao/Stub.h"
   3 #include "tao/Adapter_Registry.h"
   4 #include "tao/Adapter.h"
   5 #include "tao/SystemException.h"
   6 #include "tao/debug.h"
   7 #include "tao/TAO_Server_Request.h"
   8
   9 #include "ace/Log_Msg.h"
  10 #include "ace/OS_NS_string.h"
  11 #include "ace/CORBA_macros.h"
  12 #include <cstring>
  13
  14 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  15
  16 TAO_Adapter_Registry::TAO_Adapter_Registry (TAO_ORB_Core *)
  17   : adapters_capacity_ (16), // @@ Make it configurable
  18     adapters_count_ (0),
  19     adapters_ (nullptr)
  20 {
  21   ACE_NEW (this->adapters_,
  22            TAO_Adapter*[this->adapters_capacity_]);
  23 }
  24
  25 TAO_Adapter_Registry::~TAO_Adapter_Registry ()
  26 {
  27   for (size_t i = 0; i != this->adapters_count_; ++i)
  28     delete this->adapters_[i];
  29
  30   delete[] this->adapters_;
  31 }
  32
  33 void
  34 TAO_Adapter_Registry::close (int wait_for_completion)
  35 {
  36   try
  37     {
  38       for (size_t i = 0; i != this->adapters_count_; ++i)
  39         {
  40           this->adapters_[i]->close (wait_for_completion);
  41         }
  42     }
  43   catch (const::CORBA::Exception &ex)
  44     {
  45       if (TAO_debug_level > 3)
  46         {
  47           ex._tao_print_exception (
  48             "Exception in TAO_Adapter_Registry::close ()");
  49         }
  50       return;
  51     }
  52
  53   return;
  54 }
  55
  56 void
  57 TAO_Adapter_Registry::check_close (int wait_for_completion)
  58 {
  59   for (size_t i = 0; i != this->adapters_count_; ++i)
  60     {
  61       this->adapters_[i]->check_close (wait_for_completion);
  62     }
  63 }
  64
  65 void
  66 TAO_Adapter_Registry::insert (TAO_Adapter *adapter)
  67 {
  68   if (this->adapters_capacity_ == this->adapters_count_)
  69     {
  70       this->adapters_capacity_ *= 2;
  71       TAO_Adapter **tmp = nullptr;
  72       ACE_NEW_THROW_EX (tmp,
  73                         TAO_Adapter*[this->adapters_capacity_],
  74                         CORBA::NO_MEMORY ());
  75
  76       for (size_t i = 0; i != this->adapters_count_; ++i)
  77         tmp[i] = this->adapters_[i];
  78       delete[] this->adapters_;
  79       this->adapters_ = tmp;
  80     }
  81
  82   int const priority = adapter->priority ();
  83   for (size_t i = 0; i != this->adapters_count_; ++i)
  84     {
  85       if (this->adapters_[i]->priority () >= priority)
  86         {
  87           for (size_t j = this->adapters_count_ + 1;
  88                j > i;
  89                --j)
  90             {
  91               this->adapters_[j] = this->adapters_[j - 1];
  92             }
  93           this->adapters_[i] = adapter;
  94           ++this->adapters_count_;
  95           return;
  96         }
  97     }
  98   this->adapters_[this->adapters_count_++] = adapter;
  99 }
 100
 101 void
 102 TAO_Adapter_Registry::dispatch (TAO::ObjectKey &key,
 103                                 TAO_ServerRequest &request,
 104                                 CORBA::Object_out forward_to)
 105 {
 106   for (size_t i = 0; i != this->adapters_count_; ++i)
 107     {
 108       int const r = this->adapters_[i]->dispatch (key, request, forward_to);
 109
 110       if (r != TAO_Adapter::DS_MISMATCHED_KEY)
 111         {
 112           return;
 113         }
 114     }
 115
 116   if (!request.is_forwarded ())
 117     {
 118       throw ::CORBA::OBJECT_NOT_EXIST ();
 119     }
 120 }
 121
 122 CORBA::Object_ptr
 123 TAO_Adapter_Registry::create_collocated_object (TAO_Stub *stub,
 124                                                 const TAO_MProfile &mprofile)
 125 {
 126   for (size_t i = 0; i != this->adapters_count_; ++i)
 127     {
 128       CORBA::Object_ptr x =
 129         this->adapters_[i]->create_collocated_object (stub, mprofile);
 130       if (x != nullptr)
 131         {
 132           if (!stub->collocated_servant ())
 133             {
 134               // This adapter created an object but it was not able to locate
 135               // a servant so we need to give the rest of the adapters a chance to
 136               // initialise the stub and find a servant or forward us or whatever.
 137               for (CORBA::Long go_on = 1; go_on && i != this->adapters_count_;
 138                    ++i)
 139                 {
 140                   // initialize_collocated_object only returns 0 if it has completely
 141                   // initialised the object.
 142                   go_on = this->adapters_[i]->initialize_collocated_object (
 143                     stub);
 144                 }
 145             }
 146           return x;
 147         }
 148     }
 149   return nullptr;
 150 }
 151
 152 CORBA::Long
 153 TAO_Adapter_Registry::initialize_collocated_object (TAO_Stub *stub)
 154 {
 155   for (size_t i = 0; i != this->adapters_count_; ++i)
 156     {
 157       int const retval =
 158         this->adapters_[i]->initialize_collocated_object (stub);
 159       if (retval == 0)
 160         {
 161           // initialize_collocated_object only returns 0 if it has completely
 162           // initialised the object. We can return early.
 163           return retval;
 164         }
 165     }
 166   return 0;
 167 }
 168
 169 TAO_Adapter *
 170 TAO_Adapter_Registry::find_adapter (const char *name) const
 171 {
 172   for (TAO_Adapter **i = this->adapters_;
 173        i != this->adapters_ + this->adapters_count_;
 174        ++i)
 175     if (std::strcmp ((*i)->name (), name) == 0)
 176       return *i;
 177
 178   return nullptr;
 179 }
 180
 181 TAO_END_VERSIONED_NAMESPACE_DECL