00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012 #include "tao/ORB_Core.h"
00013 #include "tao/debug.h"
00014 #include "tao/PortableServer/ServantRetentionStrategyRetain.h"
00015 #include "tao/PortableServer/Non_Servant_Upcall.h"
00016 #include "tao/PortableServer/Servant_Upcall.h"
00017 #include "tao/PortableServer/POA_Current_Impl.h"
00018 #include "tao/PortableServer/Root_POA.h"
00019 #include "tao/PortableServer/Active_Object_Map.h"
00020 #include "tao/PortableServer/Active_Object_Map_Entry.h"
00021
00022 #if defined (TAO_HAS_MONITOR_POINTS) && (TAO_HAS_MONITOR_POINTS == 1)
00023 #include "ace/Monitor_Size.h"
00024 #endif
00025
00026 ACE_RCSID (PortableServer,
00027 ServantRetentionStrategyRetain,
00028 "$Id: ServantRetentionStrategyRetain.cpp 81665 2008-05-09 13:37:40Z parsons $")
00029
00030 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
00031
00032 namespace TAO
00033 {
00034 namespace Portable_Server
00035 {
00036 ServantRetentionStrategyRetain::ServantRetentionStrategyRetain (void) :
00037 ServantRetentionStrategyNonRetain (),
00038 active_object_map_ (),
00039 waiting_servant_deactivation_ (0)
00040 {
00041 }
00042
00043 void
00044 ServantRetentionStrategyRetain::strategy_init (TAO_Root_POA *poa)
00045 {
00046 poa_ = poa;
00047
00048
00049 TAO_Active_Object_Map *active_object_map = 0;
00050 ACE_NEW_THROW_EX (active_object_map,
00051 TAO_Active_Object_Map (!poa->system_id (),
00052 !poa->allow_multiple_activations (),
00053 poa->is_persistent (),
00054 poa->orb_core().server_factory ()->active_object_map_creation_parameters ()
00055 ), CORBA::NO_MEMORY ());
00056
00057 ACE_auto_ptr_reset (this->active_object_map_, active_object_map);
00058
00059 #if defined (TAO_HAS_MONITOR_POINTS) && (TAO_HAS_MONITOR_POINTS == 1)
00060 ACE_CString name_str ("Active_Object_Map_");
00061 name_str += poa->the_name ();
00062 active_object_map->monitor_->name (name_str.c_str ());
00063 active_object_map->monitor_->add_to_registry ();
00064 #endif
00065 }
00066
00067 void
00068 ServantRetentionStrategyRetain::strategy_cleanup (void)
00069 {
00070 }
00071
00072 void
00073 ServantRetentionStrategyRetain::deactivate_object (
00074 const PortableServer::ObjectId &id)
00075 {
00076 TAO_Active_Object_Map_Entry *active_object_map_entry = 0;
00077 int const result = this->active_object_map_->
00078 find_entry_using_user_id (id, active_object_map_entry);
00079
00080
00081
00082 if (result != 0)
00083 {
00084 throw PortableServer::POA::ObjectNotActive ();
00085 }
00086
00087 this->deactivate_map_entry (active_object_map_entry);
00088 }
00089
00090 void
00091 ServantRetentionStrategyRetain::deactivate_map_entry (
00092 TAO_Active_Object_Map_Entry *active_object_map_entry)
00093 {
00094
00095 CORBA::UShort const new_count = --active_object_map_entry->reference_count_;
00096
00097
00098
00099
00100 if (active_object_map_entry->deactivated_ == 0)
00101 {
00102 this->poa_->servant_deactivated_hook (
00103 active_object_map_entry->servant_,
00104 active_object_map_entry->user_id_);
00105 }
00106
00107 if (new_count == 0)
00108 {
00109 this->poa_->cleanup_servant (active_object_map_entry->servant_,
00110 active_object_map_entry->user_id_);
00111 }
00112 else
00113 {
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125 active_object_map_entry->deactivated_ = 1;
00126 }
00127 }
00128
00129 int
00130 ServantRetentionStrategyRetain::unbind_using_user_id (
00131 const PortableServer::ObjectId &user_id)
00132 {
00133 return this->active_object_map_->unbind_using_user_id (user_id);
00134 }
00135
00136 PortableServer::Servant
00137 ServantRetentionStrategyRetain::find_servant (
00138 const PortableServer::ObjectId &system_id)
00139 {
00140
00141 PortableServer::ObjectId_var user_id;
00142 if (active_object_map_->
00143 find_user_id_using_system_id (system_id, user_id.out()) != 0)
00144 {
00145 throw ::CORBA::OBJ_ADAPTER ();
00146 }
00147
00148
00149
00150
00151
00152 TAO_Active_Object_Map_Entry *entry = 0;
00153 PortableServer::Servant servant = 0;
00154
00155 int const result =
00156 active_object_map_->
00157 find_servant_using_system_id_and_user_id (system_id,
00158 user_id.in(),
00159 servant,
00160 entry);
00161
00162 if (result == -1)
00163 {
00164 throw PortableServer::POA::ObjectNotActive ();
00165 }
00166
00167 return servant;
00168 }
00169
00170 PortableServer::ObjectId *
00171 ServantRetentionStrategyRetain::system_id_to_object_id (
00172 const PortableServer::ObjectId &system_id)
00173 {
00174
00175
00176 PortableServer::ObjectId_var user_id;
00177 if (this->active_object_map_->
00178 find_user_id_using_system_id (system_id,
00179 user_id.out ()) != 0)
00180 {
00181 throw ::CORBA::OBJ_ADAPTER ();
00182 }
00183
00184 return user_id._retn ();
00185 }
00186
00187 PortableServer::Servant
00188 ServantRetentionStrategyRetain::user_id_to_servant (
00189 const PortableServer::ObjectId &id)
00190 {
00191
00192
00193
00194 PortableServer::Servant servant = 0;
00195
00196 if (this->active_object_map_->find_servant_using_user_id (id, servant) == -1)
00197 {
00198 throw PortableServer::POA::ObjectNotActive ();
00199 }
00200
00201 return servant;
00202 }
00203
00204 CORBA::Object_ptr
00205 ServantRetentionStrategyRetain::id_to_reference (
00206 const PortableServer::ObjectId &id,
00207 bool indirect)
00208 {
00209
00210
00211
00212 PortableServer::ObjectId_var system_id;
00213 PortableServer::Servant servant;
00214 CORBA::Short priority;
00215
00216 if (this->active_object_map_->
00217 find_servant_and_system_id_using_user_id (id,
00218 servant,
00219 system_id.out (),
00220 priority) == 0)
00221 {
00222
00223 this->poa_->key_to_object_params_.set (system_id,
00224 servant->_interface_repository_id (),
00225 servant,
00226 1,
00227 priority,
00228 indirect);
00229
00230 return this->poa_->invoke_key_to_object_helper_i (servant->_interface_repository_id (),
00231 id);
00232 }
00233 else
00234 {
00235
00236
00237 throw PortableServer::POA::ObjectNotActive ();
00238 }
00239 }
00240
00241 TAO_SERVANT_LOCATION
00242 ServantRetentionStrategyRetain::servant_present (
00243 const PortableServer::ObjectId &system_id,
00244 PortableServer::Servant &servant)
00245 {
00246
00247 PortableServer::ObjectId_var user_id;
00248 if (this->active_object_map_->
00249 find_user_id_using_system_id (system_id, user_id.out()) != 0)
00250 {
00251 throw ::CORBA::OBJ_ADAPTER ();
00252 }
00253
00254 TAO_Active_Object_Map_Entry *entry = 0;
00255 int const result = this->active_object_map_->
00256 find_servant_using_system_id_and_user_id (system_id,
00257 user_id.in(),
00258 servant,
00259 entry);
00260 if (result == 0)
00261 {
00262
00263 return TAO_SERVANT_FOUND;
00264 }
00265 else
00266 {
00267 return TAO_SERVANT_NOT_FOUND;
00268 }
00269 }
00270
00271 PortableServer::Servant
00272 ServantRetentionStrategyRetain::find_servant (
00273 const PortableServer::ObjectId &system_id,
00274 TAO::Portable_Server::Servant_Upcall &servant_upcall,
00275 TAO::Portable_Server::POA_Current_Impl &poa_current_impl)
00276 {
00277 PortableServer::ObjectId user_id;
00278
00279
00280 if (this->active_object_map_->
00281 find_user_id_using_system_id (system_id,
00282 user_id) != 0)
00283 {
00284 throw ::CORBA::OBJ_ADAPTER ();
00285 }
00286
00287 poa_current_impl.object_id(user_id);
00288 servant_upcall.user_id (&poa_current_impl.object_id());
00289
00290
00291
00292
00293
00294 PortableServer::Servant servant = 0;
00295 TAO_Active_Object_Map_Entry *active_object_map_entry = 0;
00296 int const result = this->active_object_map_->
00297 find_servant_using_system_id_and_user_id (system_id,
00298 user_id,
00299 servant,
00300 active_object_map_entry);
00301
00302
00303 if (result == 0)
00304 {
00305 servant_upcall.active_object_map_entry (active_object_map_entry);
00306
00307
00308 servant_upcall.increment_servant_refcount ();
00309 }
00310
00311 return servant;
00312 }
00313
00314 int
00315 ServantRetentionStrategyRetain::find_servant_priority (
00316 const PortableServer::ObjectId &system_id,
00317 CORBA::Short &priority)
00318 {
00319 PortableServer::ObjectId user_id;
00320
00321
00322 if (this->active_object_map_->
00323 find_user_id_using_system_id (system_id,
00324 user_id) != 0)
00325 {
00326 throw ::CORBA::OBJ_ADAPTER ();
00327 }
00328
00329
00330
00331
00332
00333 PortableServer::Servant servant = 0;
00334 TAO_Active_Object_Map_Entry *active_object_map_entry = 0;
00335 int const result = this->active_object_map_->
00336 find_servant_using_system_id_and_user_id (system_id,
00337 user_id,
00338 servant,
00339 active_object_map_entry);
00340
00341 if (result == 0)
00342 {
00343 priority = active_object_map_entry->priority_;
00344 return 0;
00345 }
00346
00347 return -1;
00348 }
00349
00350 int
00351 ServantRetentionStrategyRetain::is_servant_in_map (
00352 PortableServer::Servant servant,
00353 bool &wait_occurred_restart_call)
00354 {
00355 bool deactivated = false;
00356 int servant_in_map =
00357 this->active_object_map_->is_servant_in_map (servant, deactivated);
00358
00359 if (!servant_in_map)
00360 {
00361 return 0;
00362 }
00363 else
00364 {
00365 if (deactivated)
00366 {
00367 if (TAO_debug_level > 0)
00368 ACE_DEBUG ((LM_DEBUG,
00369 ACE_TEXT ("(%t) TAO_Root_POA::is_servant_in_map: waiting for servant to deactivate\n")));
00370
00371
00372
00373
00374
00375 wait_occurred_restart_call = true;
00376
00377 ++this->waiting_servant_deactivation_;
00378
00379 if (this->poa_->object_adapter ().enable_locking ())
00380 this->poa_->servant_deactivation_condition ().wait ();
00381
00382 --this->waiting_servant_deactivation_;
00383
00384 return 0;
00385 }
00386 else
00387 {
00388 return 1;
00389 }
00390 }
00391 }
00392
00393 int
00394 ServantRetentionStrategyRetain::is_user_id_in_map (
00395 const PortableServer::ObjectId &id,
00396 CORBA::Short priority,
00397 bool &priorities_match,
00398 bool &wait_occurred_restart_call)
00399 {
00400 bool deactivated = false;
00401 bool user_id_in_map =
00402 this->active_object_map_->is_user_id_in_map (id,
00403 priority,
00404 priorities_match,
00405 deactivated);
00406
00407 if (!user_id_in_map)
00408 {
00409 return 0;
00410 }
00411 else
00412 {
00413 if (deactivated)
00414 {
00415 if (TAO_debug_level > 0)
00416 ACE_DEBUG ((LM_DEBUG,
00417 ACE_TEXT ("(%t) TAO_Root_POA::is_user_id_in_map: waiting for servant to deactivate\n")));
00418
00419
00420
00421
00422
00423 wait_occurred_restart_call = 1;
00424
00425 ++this->waiting_servant_deactivation_;
00426
00427 if (this->poa_->object_adapter ().enable_locking ())
00428 this->poa_->servant_deactivation_condition ().wait ();
00429
00430 --this->waiting_servant_deactivation_;
00431
00432 return 0;
00433 }
00434 else
00435 {
00436 return 1;
00437 }
00438 }
00439 }
00440
00441 CORBA::ULong
00442 ServantRetentionStrategyRetain::waiting_servant_deactivation (void) const
00443 {
00444 return waiting_servant_deactivation_;
00445 }
00446
00447 void
00448 ServantRetentionStrategyRetain::deactivate_all_objects (void)
00449 {
00450
00451
00452
00453
00454
00455
00456
00457
00458
00459
00460
00461 ACE_Array_Base<TAO_Active_Object_Map_Entry *> map_entries
00462 (this->active_object_map_->current_size ());
00463
00464 size_t counter = 0;
00465 TAO_Active_Object_Map::user_id_map::iterator end
00466 = this->active_object_map_->user_id_map_->end ();
00467
00468 for (TAO_Active_Object_Map::user_id_map::iterator iter
00469 = this->active_object_map_->user_id_map_->begin ();
00470 iter != end;
00471 ++iter)
00472 {
00473 TAO_Active_Object_Map::user_id_map::value_type map_pair = *iter;
00474 TAO_Active_Object_Map_Entry *active_object_map_entry = map_pair.second ();
00475
00476 if (!active_object_map_entry->deactivated_)
00477 {
00478 map_entries[counter] = active_object_map_entry;
00479 ++counter;
00480 }
00481 }
00482
00483 for (size_t i = 0;
00484 i < counter;
00485 ++i)
00486 {
00487 this->deactivate_map_entry (map_entries[i]);
00488 }
00489 }
00490
00491 PortableServer::ObjectId *
00492 ServantRetentionStrategyRetain::servant_to_user_id (
00493 PortableServer::Servant servant)
00494 {
00495
00496
00497
00498 if (!((!this->poa_->allow_multiple_activations ()
00499 || this->poa_->allow_implicit_activation ())))
00500 {
00501 throw PortableServer::POA::WrongPolicy ();
00502 }
00503
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519 PortableServer::ObjectId_var user_id;
00520 if (!this->poa_->allow_multiple_activations () &&
00521 this->active_object_map_->
00522 find_user_id_using_servant (servant, user_id.out ()) != -1)
00523 {
00524 return user_id._retn ();
00525 }
00526
00527
00528
00529
00530
00531
00532 if (this->poa_->allow_implicit_activation ())
00533 {
00534
00535
00536
00537 PortableServer::ObjectId_var user_id;
00538 if (this->active_object_map_->
00539 bind_using_system_id_returning_user_id (servant,
00540 this->poa_->server_priority (),
00541 user_id.out ()) != 0)
00542 {
00543 throw ::CORBA::OBJ_ADAPTER ();
00544 }
00545
00546
00547
00548
00549
00550
00551
00552 this->poa_->servant_activated_hook (servant, user_id.in ());
00553
00554
00555 Non_Servant_Upcall non_servant_upcall (*this->poa_);
00556 ACE_UNUSED_ARG (non_servant_upcall);
00557
00558
00559
00560
00561
00562 servant->_add_ref ();
00563
00564 return user_id._retn ();
00565 }
00566
00567
00568
00569
00570 throw PortableServer::POA::ServantNotActive ();
00571 }
00572
00573 PortableServer::ObjectId *
00574 ServantRetentionStrategyRetain::servant_to_system_id_i (
00575 PortableServer::Servant servant,
00576 CORBA::Short &priority)
00577 {
00578
00579
00580
00581 if (!((!this->poa_->allow_multiple_activations ()
00582 || this->poa_->allow_implicit_activation ())))
00583 {
00584 throw PortableServer::POA::WrongPolicy ();
00585 }
00586
00587
00588
00589
00590
00591 PortableServer::ObjectId_var system_id;
00592 if (!this->poa_->allow_multiple_activations () &&
00593 this->active_object_map_->
00594 find_system_id_using_servant (servant,
00595 system_id.out (),
00596 priority) != -1)
00597 {
00598 return system_id._retn ();
00599 }
00600
00601 #if defined (CORBA_E_COMPACT) || defined (CORBA_E_MICRO)
00602
00603
00604 throw PortableServer::POA::WrongPolicy ();
00605 #endif
00606
00607
00608
00609
00610
00611
00612 if (this->poa_->allow_implicit_activation ())
00613 {
00614
00615
00616
00617 PortableServer::ObjectId_var system_id;
00618 if (this->active_object_map_->
00619 bind_using_system_id_returning_system_id (servant,
00620 priority,
00621 system_id.out ()) != 0)
00622 {
00623 throw ::CORBA::OBJ_ADAPTER ();
00624 }
00625
00626
00627
00628
00629
00630
00631
00632 this->poa_->servant_activated_hook (servant, system_id.in ());
00633
00634
00635 Non_Servant_Upcall non_servant_upcall (*this->poa_);
00636 ACE_UNUSED_ARG (non_servant_upcall);
00637
00638
00639
00640
00641
00642 servant->_add_ref ();
00643
00644 return system_id._retn ();
00645 }
00646
00647
00648 throw PortableServer::POA::ServantNotActive ();
00649 }
00650
00651 CORBA::Object_ptr
00652 ServantRetentionStrategyRetain::servant_to_reference (
00653 PortableServer::Servant servant)
00654 {
00655
00656
00657
00658
00659
00660
00661 CORBA::Short priority = this->poa_->server_priority ();
00662
00663 PortableServer::ObjectId_var system_id =
00664 this->servant_to_system_id_i (servant, priority);
00665
00666 PortableServer::ObjectId user_id;
00667
00668
00669
00670 if (this->active_object_map_->
00671 find_user_id_using_system_id (system_id.in (), user_id) != 0)
00672 {
00673 throw ::CORBA::OBJ_ADAPTER ();
00674 }
00675
00676
00677 this->poa_->key_to_object_params_.set (
00678 system_id,
00679 servant->_interface_repository_id (),
00680 servant,
00681 1,
00682 priority,
00683 true);
00684
00685
00686
00687
00688
00689
00690 return this->poa_->invoke_key_to_object_helper_i (
00691 servant->_interface_repository_id (), user_id);
00692 }
00693
00694 PortableServer::ObjectId *
00695 ServantRetentionStrategyRetain::activate_object (
00696 PortableServer::Servant servant,
00697 CORBA::Short priority,
00698 bool &wait_occurred_restart_call)
00699 {
00700 if (!this->poa_->has_system_id ())
00701 {
00702 throw PortableServer::POA::WrongPolicy ();
00703 }
00704
00705 bool may_activate =
00706 this->poa_->is_servant_activation_allowed (servant, wait_occurred_restart_call);
00707
00708 if (!may_activate)
00709 {
00710 if (wait_occurred_restart_call)
00711 {
00712 return 0;
00713 }
00714 else
00715 {
00716 throw PortableServer::POA::ServantAlreadyActive ();
00717 }
00718 }
00719
00720
00721
00722
00723 PortableServer::ObjectId_var user_id;
00724 if (this->active_object_map_->
00725 bind_using_system_id_returning_user_id (servant,
00726 priority,
00727 user_id.out ()) != 0)
00728 {
00729 throw ::CORBA::OBJ_ADAPTER ();
00730 }
00731
00732
00733
00734
00735
00736
00737
00738 this->poa_->servant_activated_hook (servant, user_id.in ());
00739
00740
00741 Non_Servant_Upcall non_servant_upcall (*this->poa_);
00742 ACE_UNUSED_ARG (non_servant_upcall);
00743
00744
00745
00746
00747
00748 servant->_add_ref ();
00749
00750 return user_id._retn ();
00751 }
00752
00753 #if !defined (CORBA_E_MICRO)
00754 void
00755 ServantRetentionStrategyRetain::activate_object_with_id (
00756 const PortableServer::ObjectId &id,
00757 PortableServer::Servant servant,
00758 CORBA::Short priority,
00759 bool &wait_occurred_restart_call)
00760 {
00761
00762
00763
00764
00765
00766
00767
00768
00769
00770 if (this->poa_->has_system_id () &&
00771 !this->poa_->is_poa_generated_id (id))
00772 {
00773 throw ::CORBA::BAD_PARAM ();
00774 }
00775
00776
00777
00778
00779 bool priorities_match = true;
00780 bool result =
00781 this->is_user_id_in_map (id,
00782 priority,
00783 priorities_match,
00784 wait_occurred_restart_call);
00785
00786
00787
00788
00789 if (result)
00790 {
00791 throw PortableServer::POA::ObjectAlreadyActive ();
00792 }
00793 else if (wait_occurred_restart_call)
00794 {
00795
00796
00797
00798 return;
00799 }
00800
00801
00802
00803
00804
00805
00806
00807 if (!priorities_match)
00808 {
00809 throw ::CORBA::BAD_INV_ORDER (CORBA::OMGVMCID | 1,
00810 CORBA::COMPLETED_NO);
00811 }
00812
00813 bool const may_activate =
00814 this->poa_->is_servant_activation_allowed (servant, wait_occurred_restart_call);
00815
00816 if (!may_activate)
00817 {
00818 if (wait_occurred_restart_call)
00819 {
00820 return;
00821 }
00822 else
00823 {
00824 throw PortableServer::POA::ServantAlreadyActive ();
00825 }
00826 }
00827
00828
00829
00830
00831 if (this->active_object_map_->bind_using_user_id (servant,
00832 id,
00833 priority) != 0)
00834 {
00835 throw ::CORBA::OBJ_ADAPTER ();
00836 }
00837
00838
00839
00840
00841
00842
00843
00844 this->poa_->servant_activated_hook (servant, id);
00845
00846
00847 Non_Servant_Upcall non_servant_upcall (*this->poa_);
00848 ACE_UNUSED_ARG (non_servant_upcall);
00849
00850
00851
00852
00853
00854 servant->_add_ref ();
00855 }
00856 #endif
00857
00858 CORBA::Object_ptr
00859 ServantRetentionStrategyRetain::create_reference (
00860 const char *intf,
00861 CORBA::Short priority)
00862 {
00863
00864
00865
00866
00867
00868
00869
00870
00871
00872 PortableServer::ObjectId_var system_id;
00873 PortableServer::ObjectId user_id;
00874
00875 if (this->active_object_map_->
00876 bind_using_system_id_returning_system_id (0,
00877 priority,
00878 system_id.out ()) != 0)
00879 {
00880 throw ::CORBA::OBJ_ADAPTER ();
00881 }
00882
00883
00884 if (this->active_object_map_->
00885 find_user_id_using_system_id (system_id.in (),
00886 user_id) != 0)
00887 {
00888 throw ::CORBA::OBJ_ADAPTER ();
00889 }
00890
00891
00892 this->poa_->key_to_object_params_.set (system_id,
00893 intf,
00894 0,
00895 1,
00896 priority,
00897 true);
00898
00899 return this->poa_->invoke_key_to_object_helper_i (intf,
00900 user_id);
00901 }
00902
00903 #if !defined (CORBA_E_MICRO)
00904 CORBA::Object_ptr
00905 ServantRetentionStrategyRetain::create_reference_with_id (
00906 const PortableServer::ObjectId &oid,
00907 const char *intf,
00908 CORBA::Short priority)
00909 {
00910
00911
00912
00913
00914
00915
00916
00917
00918 PortableServer::Servant servant = 0;
00919 PortableServer::ObjectId_var system_id;
00920
00921
00922
00923
00924
00925
00926
00927 if (this->active_object_map_->
00928 find_system_id_using_user_id (oid,
00929 priority,
00930 system_id.out ()) != 0)
00931 {
00932 throw ::CORBA::OBJ_ADAPTER ();
00933 }
00934
00935
00936 this->poa_->key_to_object_params_.set (system_id,
00937 intf,
00938 servant,
00939 1,
00940 priority,
00941 true);
00942
00943 return this->poa_->invoke_key_to_object_helper_i (intf, oid);
00944 }
00945 #endif
00946
00947 int
00948 ServantRetentionStrategyRetain::rebind_using_user_id_and_system_id (
00949 PortableServer::Servant servant,
00950 const PortableServer::ObjectId &user_id,
00951 const PortableServer::ObjectId &system_id,
00952 TAO::Portable_Server::Servant_Upcall &servant_upcall)
00953 {
00954 TAO_Active_Object_Map_Entry *entry = 0;
00955 int result = this->active_object_map_->
00956 rebind_using_user_id_and_system_id (servant,
00957 user_id,
00958 system_id,
00959 entry);
00960 servant_upcall.active_object_map_entry(entry);
00961
00962 return result;
00963 }
00964
00965 CORBA::Boolean
00966 ServantRetentionStrategyRetain::servant_has_remaining_activations (
00967 PortableServer::Servant servant)
00968 {
00969 return this->active_object_map_->remaining_activations (servant);
00970 }
00971
00972
00973 ::PortableServer::ServantRetentionPolicyValue
00974 ServantRetentionStrategyRetain::type(void) const
00975 {
00976 return ::PortableServer::RETAIN;
00977 }
00978
00979 }
00980 }
00981
00982 TAO_END_VERSIONED_NAMESPACE_DECL