diff options
Diffstat (limited to 'TAO/tao/ImR_Client')
22 files changed, 14916 insertions, 0 deletions
diff --git a/TAO/tao/ImR_Client/ImR_Client_Adapter_Impl.cpp b/TAO/tao/ImR_Client/ImR_Client_Adapter_Impl.cpp new file mode 100644 index 00000000000..e6fe32e4a2b --- /dev/null +++ b/TAO/tao/ImR_Client/ImR_Client_Adapter_Impl.cpp @@ -0,0 +1,220 @@ +// $Id$ + +#include "ImR_Client_Adapter_Impl.h" + +#include "tao/debug.h" +#include "tao/ORB_Core.h" +#include "tao/Stub.h" +#include "tao/Profile.h" +#include "tao/PortableServer/Root_POA.h" +#include "tao/PortableServer/Non_Servant_Upcall.h" +#include "tao/ImR_Client/ServerObject_i.h" +#include "tao/ImR_Client/ImplRepoC.h" + +ACE_RCSID (IFR_Client, + IFR_Client_Adapter_Impl, + "$Id$") + +namespace TAO +{ + namespace ImR_Client + { + ImR_Client_Adapter_Impl::~ImR_Client_Adapter_Impl (void) + { + } + + void + ImR_Client_Adapter_Impl::imr_notify_startup ( + TAO_Root_POA* poa ACE_ENV_ARG_DECL) + { + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, "Notifying ImR of startup\n")); + + CORBA::Object_var imr = poa->orb_core ().implrepo_service (); + + if (CORBA::is_nil (imr.in ())) + return; + + ImplementationRepository::Administration_var imr_locator; + + { + // ATTENTION: Trick locking here, see class header for details + TAO::Portable_Server::Non_Servant_Upcall non_servant_upcall (*poa); + ACE_UNUSED_ARG (non_servant_upcall); + + imr_locator = + ImplementationRepository::Administration::_narrow (imr.in () ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + + if (CORBA::is_nil(imr_locator.in ())) + return; + + TAO_Root_POA *root_poa = poa->object_adapter ().root_poa (); + ACE_NEW_THROW_EX (this->server_object_, + ServerObject_i (poa->orb_core ().orb (), + root_poa), + CORBA::NO_MEMORY ()); + ACE_CHECK; + + PortableServer::ServantBase_var safe_servant (this->server_object_); + ACE_UNUSED_ARG (safe_servant); + + // Since this method is called from the POA constructor, there + // shouldn't be any waiting required. Therefore, + // <wait_occurred_restart_call_ignored> can be ignored. + int wait_occurred_restart_call_ignored = 0; + + // Activate the servant in the root poa. + PortableServer::ObjectId_var id = + root_poa->activate_object_i (this->server_object_, + poa->server_priority (), + wait_occurred_restart_call_ignored + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + CORBA::Object_var obj = root_poa->id_to_reference_i (id.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + ImplementationRepository::ServerObject_var svr + = ImplementationRepository::ServerObject::_narrow (obj.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + if (!svr->_stubobj () || !svr->_stubobj ()->profile_in_use ()) + { + ACE_ERROR ((LM_ERROR, "Invalid ImR ServerObject, bailing out.\n")); + return; + } + + CORBA::String_var ior = + svr->_stubobj ()->profile_in_use ()->to_string (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + // Search for "corbaloc:" alone, without the protocol. This code + // should be protocol neutral. + const char corbaloc[] = "corbaloc:"; + char *pos = ACE_OS::strstr (ior.inout (), corbaloc); + pos = ACE_OS::strchr (pos + sizeof (corbaloc), ':'); + + pos = ACE_OS::strchr (pos + 1, + svr->_stubobj ()->profile_in_use ()->object_key_delimiter ()); + + ACE_CString partial_ior(ior.in (), (pos - ior.in()) + 1); + + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + "Informing IMR that we are running at: %s\n", + ACE_TEXT_CHAR_TO_TCHAR (partial_ior.c_str()))); + + ACE_TRY + { + // ATTENTION: Trick locking here, see class header for details + TAO::Portable_Server::Non_Servant_Upcall non_servant_upcall (*poa); + ACE_UNUSED_ARG (non_servant_upcall); + + imr_locator->server_is_running (poa->name().c_str (), + partial_ior.c_str(), + svr.in() + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + ACE_CATCH (CORBA::SystemException, sysex) + { + // Avoid warnings on platforms with native C++ exceptions + ACE_UNUSED_ARG (sysex); + ACE_RE_THROW; + } + ACE_CATCHANY + { + ACE_TRY_THROW (CORBA::TRANSIENT ( + CORBA::SystemException::_tao_minor_code (TAO_IMPLREPO_MINOR_CODE, 0), + CORBA::COMPLETED_NO)); + } + ACE_ENDTRY; + ACE_CHECK; + + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, "Successfully notified ImR of Startup\n")); + } + + void + ImR_Client_Adapter_Impl::imr_notify_shutdown ( + TAO_Root_POA* poa ACE_ENV_ARG_DECL) + { + // Notify the Implementation Repository about shutting down. + CORBA::Object_var imr = poa->orb_core ().implrepo_service (); + + // Check to see if there was an imr returned. + // If none, return ourselves. + if (CORBA::is_nil (imr.in ())) + return; + + ACE_TRY_NEW_ENV + { + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, "Notifing IMR of Shutdown server:%s\n", poa->the_name())); + + // ATTENTION: Trick locking here, see class header for details + TAO::Portable_Server::Non_Servant_Upcall non_servant_upcall (*poa); + ACE_UNUSED_ARG (non_servant_upcall); + + // Get the IMR's administrative object and call shutting_down on it + ImplementationRepository::Administration_var imr_locator = + ImplementationRepository::Administration::_narrow (imr.in () ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + imr_locator->server_is_shutting_down (poa->the_name () ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "POA::imr_notify_shutdown()"); + // Ignore exceptions + } + ACE_ENDTRY; + + if (this->server_object_) + { + TAO_Root_POA *root_poa = poa->object_adapter ().root_poa (); + + if (!root_poa) + { + ACE_THROW (CORBA::OBJ_ADAPTER ()); + } + + PortableServer::ObjectId_var id = + root_poa->servant_to_id_i (this->server_object_ + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + root_poa->deactivate_object_i (id.in() ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + } + + // ********************************************************************* + + // Initialization and registration of dynamic service object. + + int + ImR_Client_Adapter_Impl::Initializer (void) + { + TAO_Root_POA::imr_client_adapter_name ("Concrete_ImR_Client_Adapter"); + + return ACE_Service_Config::process_directive (ace_svc_desc_ImR_Client_Adapter_Impl); + } + + ACE_STATIC_SVC_DEFINE ( + ImR_Client_Adapter_Impl, + ACE_TEXT ("Concrete_ImR_Client_Adapter"), + ACE_SVC_OBJ_T, + &ACE_SVC_NAME (ImR_Client_Adapter_Impl), + ACE_Service_Type::DELETE_THIS | ACE_Service_Type::DELETE_OBJ, + 0 + ) + + ACE_FACTORY_DEFINE (TAO_IMR_Client, ImR_Client_Adapter_Impl) + } +} diff --git a/TAO/tao/ImR_Client/ImR_Client_Adapter_Impl.h b/TAO/tao/ImR_Client/ImR_Client_Adapter_Impl.h new file mode 100644 index 00000000000..7bba1f8d399 --- /dev/null +++ b/TAO/tao/ImR_Client/ImR_Client_Adapter_Impl.h @@ -0,0 +1,88 @@ +// -*- C++ -*- + +//============================================================================= +/** + * @file ImR_Client_Adapter_Impl.h + * + * $Id$ + * + * @author Johnny Willemsen <jwillemsen@remedy.nl> + */ +//============================================================================= + + +#ifndef TAO_IMR_CLIENT_ADAPTER_IMPL_H +#define TAO_IMR_CLIENT_ADAPTER_IMPL_H + +#include /**/ "ace/pre.h" + +#include "imr_client_export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "tao/PortableServer/ImR_Client_Adapter.h" + +#include "ace/Service_Config.h" + +class ServerObject_i; + +namespace TAO +{ + namespace ImR_Client + { + /** + * @class IFR_Client_Adapter_Impl + * + * @brief IFR_Client_Adapter_Impl. + * + * Class that adapts various functions in the PortableServer library + * which use the Implementation Repository. This is the derived class + * that contains the actual implementations. + */ + class TAO_IMR_Client_Export ImR_Client_Adapter_Impl + : public ::TAO::Portable_Server::ImR_Client_Adapter + { + public: + virtual ~ImR_Client_Adapter_Impl (void); + + // Used to force the initialization of the PortableServer code. + static int Initializer (void); + + /// ImplRepo helper method, notify the ImplRepo on startup + virtual void imr_notify_startup (TAO_Root_POA* poa ACE_ENV_ARG_DECL); + + /// ImplRepo helper method, notify the ImplRepo on shutdown + virtual void imr_notify_shutdown (TAO_Root_POA* poa ACE_ENV_ARG_DECL); + + private: + /// Implementation Repository Server Object + ServerObject_i *server_object_; + }; + + ACE_STATIC_SVC_DECLARE (ImR_Client_Adapter_Impl) + ACE_FACTORY_DECLARE (TAO_IMR_Client, ImR_Client_Adapter_Impl) + + #if defined(ACE_HAS_BROKEN_STATIC_CONSTRUCTORS) + + typedef int (*TAO_Module_Initializer) (void); + + static TAO_Module_Initializer + TAO_Requires_ImR_Client_Initializer = + &TAO::ImR_Client::ImR_Client_Adapter_Impl::Initializer; + + #else + + static int + TAO_Requires_ImR_Client_Initializer = + TAO::ImR_Client::ImR_Client_Adapter_Impl::Initializer (); + + #endif /* ACE_HAS_BROKEN_STATIC_CONSTRUCTORS */ + + } +} + +#include /**/ "ace/post.h" + +#endif /* TAO_IMR_CLIENT_ADAPTER_IMPL_H */ diff --git a/TAO/tao/ImR_Client/ImplRepo.pidl b/TAO/tao/ImR_Client/ImplRepo.pidl new file mode 100644 index 00000000000..475f22faf45 --- /dev/null +++ b/TAO/tao/ImR_Client/ImplRepo.pidl @@ -0,0 +1,192 @@ +// -*- IDL -*- + +//============================================================================= +/** + * @file ImplRepo.pidl + * + * $Id$ + * + * This file was used to generate the code in ImplRepo{C,S}.{h,inl,cpp} + * + * The command used to generate code from this file is: + * + * tao_idl -Gp -Gd -Ge 1 -Sc -GT -Wb,export_macro=TAO_IMR_Client_Export -Wb,export_include=imr_client_export.h -Wb,pre_include="ace/pre.h" -Wb,post_include="ace/post.h" ImplRepo.pidl + * + */ +//============================================================================= + +#include <tao/ImR_Client/ServerObject.pidl> + +module ImplementationRepository +{ + // = Exceptions + + /// Object already bound in the Implementation Repository + exception AlreadyRegistered {}; + + /// The server could not be restarted. + exception CannotActivate + { + string reason; + }; + + /// Object not found in the Implementation Repository + exception NotFound {}; + + /// One environment variable/value pair. + struct EnvironmentVariable + { + string name; + string value; + }; + + /// Complete Environment. + typedef sequence<EnvironmentVariable> EnvironmentList; + + /// The type of Activation + enum ActivationMode {NORMAL, MANUAL, PER_CLIENT, AUTO_START}; + + /// Options used to start up the server. + struct StartupOptions + { + /// Startup command (program name and arguments). + string command_line; + + /// Environment Variables. + EnvironmentList environment; + + /// Working directory. + string working_directory; + + /// Activation Mode + ActivationMode activation; + + /// Name of the activator + string activator; + + /// Number of retries allowed + long start_limit; + }; + + struct ServerInformation + { + /// Server name. + string server; + + /// How to start up the server. + StartupOptions startup; + + /// This is used in places that require a partial IOR with + /// just the ObjectKey missing. + string partial_ior; + }; + + typedef sequence <ServerInformation> ServerInformationList; + + /** + * @brief The Server Information Iterator Interface + * + * Interface for iterating over servers returned with + * Administration::list (). + */ + interface ServerInformationIterator + { + /// This operation returns at most the requested number of + /// servers. + /// If how_many == 0, then returns all servers + boolean next_n (in unsigned long how_many, + out ServerInformationList servers); + + /// This operation destroys the iterator. + void destroy (); + }; + + /** + * @brief The Implementation Repository Administration Interface + * + * This interface exports all the administration functionality of + * the Implementation Repository. + */ + interface Administration + { + /// Activate server that is named <server>. + /// + /// The <NotFound> exception is raised when <server> is not found + /// in the Implementation Repository. The <CannotActivate> exception + /// is raised when <server> is found in the Repository but could not be + /// activated. + void activate_server (in string server) + raises (NotFound, CannotActivate); + + /// Register the <options> to specify how the <server> should be + /// restarted when a client asks for it. + /// + /// The <AlreadyRegistered> exception is raised when <server> has + /// already been registered with the Implementation Repository. + /// The <NotFound> exception is raised when the activator specified + /// in the options is not registered. + void register_server (in string server, + in StartupOptions options) + raises (AlreadyRegistered, NotFound); + + /// Update the <options> to specify how the <server> should be + /// restarted when a client asks for it. Will register the server + /// if not already registered. + /// The <AlreadyRegistered> exception is raised when <server> has + /// already been registered with a different activator. + /// The <NotFound> exception is raised when the activator specified + /// in the options is not registered. + void reregister_server (in string server, + in StartupOptions options) + raises(AlreadyRegistered, NotFound); + + /// Remove <server> from the Implementation Repository. + /// + /// The <NotFound> exception is raised when <server> is not found + /// in the Implementation Repository. + void remove_server (in string server) + raises (NotFound); + + /// Tries to shutdown the server, first gracefully, then ungracefully. + /// + /// The <NotFound> exception is raised when <server> is not found + /// in the Implementation Repository. + void shutdown_server (in string server) + raises (NotFound); + + /// Used to notify the Implementation Repository that <server> is alive + /// and well at <partial_ior>. + /// + /// The <NotFound> exception is raised when <server> is not found + /// in the Implementation Repository. + void server_is_running (in string server, + in string partial_ior, + in ServerObject server_object) + raises (NotFound); + + /// Used to tell the Implementation Repository that <server> is shutting + /// down. + /// + /// The <NotFound> exception is raised when <server> is not found + /// in the Implementation Repository. + + void server_is_shutting_down (in string server) + raises (NotFound); + + /// Returns the startup information for a given <server>. + /// + /// The <NotFound> exception is raised when <server> is not found + /// in the Implementation Repository. + void find (in string server, out ServerInformation info) + raises (NotFound); + + /// Returns at most <how_many> servers in <server_list>. If there + /// are additional servers, they can be received through the + /// <server_iterator>. If there are no more servers, then + /// <server_iterator> is null. + /// If how_many == 0, then returns all servers. + void list (in unsigned long how_many, + out ServerInformationList server_list, + out ServerInformationIterator server_iterator); + }; +}; diff --git a/TAO/tao/ImR_Client/ImplRepoA.cpp b/TAO/tao/ImR_Client/ImplRepoA.cpp new file mode 100644 index 00000000000..978485a6b33 --- /dev/null +++ b/TAO/tao/ImR_Client/ImplRepoA.cpp @@ -0,0 +1,1750 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// and +// Institute for Software Integrated Systems +// Vanderbilt University +// Nashville, TN +// USA +// http://www.isis.vanderbilt.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +#include "ImplRepoC.h" +#include "tao/Typecode.h" +#include "tao/CDR.h" +#include "tao/Any.h" +#include "tao/Any_Impl_T.h" +#include "tao/Any_Dual_Impl_T.h" +#include "tao/Any_Basic_Impl_T.h" + +// TAO_IDL - Generated from +// be\be_visitor_typecode/typecode_defn.cpp:295 + +static const CORBA::Long _oc_ImplementationRepository_EnvironmentVariable[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 53, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f456e76), + ACE_NTOHL (0x69726f6e), + ACE_NTOHL (0x6d656e74), + ACE_NTOHL (0x56617269), + ACE_NTOHL (0x61626c65), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0 + 20, + ACE_NTOHL (0x456e7669), + ACE_NTOHL (0x726f6e6d), + ACE_NTOHL (0x656e7456), + ACE_NTOHL (0x61726961), + ACE_NTOHL (0x626c6500), // name = EnvironmentVariable + 2, // member count + 5, + ACE_NTOHL (0x6e616d65), + ACE_NTOHL (0x0), // name = name + CORBA::tk_string, + 0U, // string length + 6, + ACE_NTOHL (0x76616c75), + ACE_NTOHL (0x65000000), // name = value + CORBA::tk_string, + 0U, // string length +}; + +static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_EnvironmentVariable ( + CORBA::tk_struct, + sizeof (_oc_ImplementationRepository_EnvironmentVariable), + (char *) &_oc_ImplementationRepository_EnvironmentVariable, + 0, + 0 + ); + +namespace ImplementationRepository +{ + ::CORBA::TypeCode_ptr _tc_EnvironmentVariable = + &_tc_TAO_tc_ImplementationRepository_EnvironmentVariable; +} + +// TAO_IDL - Generated from +// be\be_visitor_typecode/typecode_defn.cpp:295 + +static const CORBA::Long _oc_ImplementationRepository_EnvironmentList[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 49, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f456e76), + ACE_NTOHL (0x69726f6e), + ACE_NTOHL (0x6d656e74), + ACE_NTOHL (0x4c697374), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentList:1.0 + 16, + ACE_NTOHL (0x456e7669), + ACE_NTOHL (0x726f6e6d), + ACE_NTOHL (0x656e744c), + ACE_NTOHL (0x69737400), // name = EnvironmentList + CORBA::tk_sequence, // typecode kind + 148, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + CORBA::tk_struct, // typecode kind + 132, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 53, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f456e76), + ACE_NTOHL (0x69726f6e), + ACE_NTOHL (0x6d656e74), + ACE_NTOHL (0x56617269), + ACE_NTOHL (0x61626c65), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0 + 20, + ACE_NTOHL (0x456e7669), + ACE_NTOHL (0x726f6e6d), + ACE_NTOHL (0x656e7456), + ACE_NTOHL (0x61726961), + ACE_NTOHL (0x626c6500), // name = EnvironmentVariable + 2, // member count + 5, + ACE_NTOHL (0x6e616d65), + ACE_NTOHL (0x0), // name = name + CORBA::tk_string, + 0U, // string length + 6, + ACE_NTOHL (0x76616c75), + ACE_NTOHL (0x65000000), // name = value + CORBA::tk_string, + 0U, // string length + + 0U, + +}; + +static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_EnvironmentList ( + CORBA::tk_alias, + sizeof (_oc_ImplementationRepository_EnvironmentList), + (char *) &_oc_ImplementationRepository_EnvironmentList, + 0, + 0 + ); + +namespace ImplementationRepository +{ + ::CORBA::TypeCode_ptr _tc_EnvironmentList = + &_tc_TAO_tc_ImplementationRepository_EnvironmentList; +} + +// TAO_IDL - Generated from +// be\be_visitor_typecode/typecode_defn.cpp:295 + +static const CORBA::Long _oc_ImplementationRepository_ActivationMode[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 48, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f416374), + ACE_NTOHL (0x69766174), + ACE_NTOHL (0x696f6e4d), + ACE_NTOHL (0x6f64653a), + ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/ActivationMode:1.0 + 15, + ACE_NTOHL (0x41637469), + ACE_NTOHL (0x76617469), + ACE_NTOHL (0x6f6e4d6f), + ACE_NTOHL (0x64650000), // name = ActivationMode + 4, // member count + 7, + ACE_NTOHL (0x4e4f524d), + ACE_NTOHL (0x414c0000), // name = NORMAL + 7, + ACE_NTOHL (0x4d414e55), + ACE_NTOHL (0x414c0000), // name = MANUAL + 11, + ACE_NTOHL (0x5045525f), + ACE_NTOHL (0x434c4945), + ACE_NTOHL (0x4e540000), // name = PER_CLIENT + 11, + ACE_NTOHL (0x4155544f), + ACE_NTOHL (0x5f535441), + ACE_NTOHL (0x52540000), // name = AUTO_START + }; + +static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ActivationMode ( + CORBA::tk_enum, + sizeof (_oc_ImplementationRepository_ActivationMode), + (char *) &_oc_ImplementationRepository_ActivationMode, + 0, + 0 + ); + +namespace ImplementationRepository +{ + ::CORBA::TypeCode_ptr _tc_ActivationMode = + &_tc_TAO_tc_ImplementationRepository_ActivationMode; +} + +// TAO_IDL - Generated from +// be\be_visitor_typecode/typecode_defn.cpp:295 + +static const CORBA::Long _oc_ImplementationRepository_StartupOptions[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 48, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f537461), + ACE_NTOHL (0x72747570), + ACE_NTOHL (0x4f707469), + ACE_NTOHL (0x6f6e733a), + ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/StartupOptions:1.0 + 15, + ACE_NTOHL (0x53746172), + ACE_NTOHL (0x7475704f), + ACE_NTOHL (0x7074696f), + ACE_NTOHL (0x6e730000), // name = StartupOptions + 6, // member count + 13, + ACE_NTOHL (0x636f6d6d), + ACE_NTOHL (0x616e645f), + ACE_NTOHL (0x6c696e65), + ACE_NTOHL (0x0), // name = command_line + CORBA::tk_string, + 0U, // string length + 12, + ACE_NTOHL (0x656e7669), + ACE_NTOHL (0x726f6e6d), + ACE_NTOHL (0x656e7400), // name = environment + CORBA::tk_alias, // typecode kind for typedefs + 236, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 49, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f456e76), + ACE_NTOHL (0x69726f6e), + ACE_NTOHL (0x6d656e74), + ACE_NTOHL (0x4c697374), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentList:1.0 + 16, + ACE_NTOHL (0x456e7669), + ACE_NTOHL (0x726f6e6d), + ACE_NTOHL (0x656e744c), + ACE_NTOHL (0x69737400), // name = EnvironmentList + CORBA::tk_sequence, // typecode kind + 148, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + CORBA::tk_struct, // typecode kind + 132, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 53, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f456e76), + ACE_NTOHL (0x69726f6e), + ACE_NTOHL (0x6d656e74), + ACE_NTOHL (0x56617269), + ACE_NTOHL (0x61626c65), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0 + 20, + ACE_NTOHL (0x456e7669), + ACE_NTOHL (0x726f6e6d), + ACE_NTOHL (0x656e7456), + ACE_NTOHL (0x61726961), + ACE_NTOHL (0x626c6500), // name = EnvironmentVariable + 2, // member count + 5, + ACE_NTOHL (0x6e616d65), + ACE_NTOHL (0x0), // name = name + CORBA::tk_string, + 0U, // string length + 6, + ACE_NTOHL (0x76616c75), + ACE_NTOHL (0x65000000), // name = value + CORBA::tk_string, + 0U, // string length + + 0U, + + + 18, + ACE_NTOHL (0x776f726b), + ACE_NTOHL (0x696e675f), + ACE_NTOHL (0x64697265), + ACE_NTOHL (0x63746f72), + ACE_NTOHL (0x79000000), // name = working_directory + CORBA::tk_string, + 0U, // string length + 11, + ACE_NTOHL (0x61637469), + ACE_NTOHL (0x76617469), + ACE_NTOHL (0x6f6e0000), // name = activation + CORBA::tk_enum, // typecode kind + 136, // encapsulation length +TAO_ENCAP_BYTE_ORDER, // byte order + 48, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f416374), + ACE_NTOHL (0x69766174), + ACE_NTOHL (0x696f6e4d), + ACE_NTOHL (0x6f64653a), + ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/ActivationMode:1.0 + 15, + ACE_NTOHL (0x41637469), + ACE_NTOHL (0x76617469), + ACE_NTOHL (0x6f6e4d6f), + ACE_NTOHL (0x64650000), // name = ActivationMode + 4, // member count + 7, + ACE_NTOHL (0x4e4f524d), + ACE_NTOHL (0x414c0000), // name = NORMAL + 7, + ACE_NTOHL (0x4d414e55), + ACE_NTOHL (0x414c0000), // name = MANUAL + 11, + ACE_NTOHL (0x5045525f), + ACE_NTOHL (0x434c4945), + ACE_NTOHL (0x4e540000), // name = PER_CLIENT + 11, + ACE_NTOHL (0x4155544f), + ACE_NTOHL (0x5f535441), + ACE_NTOHL (0x52540000), // name = AUTO_START + + 10, + ACE_NTOHL (0x61637469), + ACE_NTOHL (0x7661746f), + ACE_NTOHL (0x72000000), // name = activator + CORBA::tk_string, + 0U, // string length + 12, + ACE_NTOHL (0x73746172), + ACE_NTOHL (0x745f6c69), + ACE_NTOHL (0x6d697400), // name = start_limit + CORBA::tk_long, + +}; + +static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_StartupOptions ( + CORBA::tk_struct, + sizeof (_oc_ImplementationRepository_StartupOptions), + (char *) &_oc_ImplementationRepository_StartupOptions, + 0, + 0 + ); + +namespace ImplementationRepository +{ + ::CORBA::TypeCode_ptr _tc_StartupOptions = + &_tc_TAO_tc_ImplementationRepository_StartupOptions; +} + +// TAO_IDL - Generated from +// be\be_visitor_typecode/typecode_defn.cpp:295 + +static const CORBA::Long _oc_ImplementationRepository_ServerInformation[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 51, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f536572), + ACE_NTOHL (0x76657249), + ACE_NTOHL (0x6e666f72), + ACE_NTOHL (0x6d617469), + ACE_NTOHL (0x6f6e3a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:ImplementationRepository/ServerInformation:1.0 + 18, + ACE_NTOHL (0x53657276), + ACE_NTOHL (0x6572496e), + ACE_NTOHL (0x666f726d), + ACE_NTOHL (0x6174696f), + ACE_NTOHL (0x6e000000), // name = ServerInformation + 3, // member count + 7, + ACE_NTOHL (0x73657276), + ACE_NTOHL (0x65720000), // name = server + CORBA::tk_string, + 0U, // string length + 8, + ACE_NTOHL (0x73746172), + ACE_NTOHL (0x74757000), // name = startup + CORBA::tk_struct, // typecode kind + 604, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 48, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f537461), + ACE_NTOHL (0x72747570), + ACE_NTOHL (0x4f707469), + ACE_NTOHL (0x6f6e733a), + ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/StartupOptions:1.0 + 15, + ACE_NTOHL (0x53746172), + ACE_NTOHL (0x7475704f), + ACE_NTOHL (0x7074696f), + ACE_NTOHL (0x6e730000), // name = StartupOptions + 6, // member count + 13, + ACE_NTOHL (0x636f6d6d), + ACE_NTOHL (0x616e645f), + ACE_NTOHL (0x6c696e65), + ACE_NTOHL (0x0), // name = command_line + CORBA::tk_string, + 0U, // string length + 12, + ACE_NTOHL (0x656e7669), + ACE_NTOHL (0x726f6e6d), + ACE_NTOHL (0x656e7400), // name = environment + CORBA::tk_alias, // typecode kind for typedefs + 236, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 49, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f456e76), + ACE_NTOHL (0x69726f6e), + ACE_NTOHL (0x6d656e74), + ACE_NTOHL (0x4c697374), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentList:1.0 + 16, + ACE_NTOHL (0x456e7669), + ACE_NTOHL (0x726f6e6d), + ACE_NTOHL (0x656e744c), + ACE_NTOHL (0x69737400), // name = EnvironmentList + CORBA::tk_sequence, // typecode kind + 148, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + CORBA::tk_struct, // typecode kind + 132, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 53, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f456e76), + ACE_NTOHL (0x69726f6e), + ACE_NTOHL (0x6d656e74), + ACE_NTOHL (0x56617269), + ACE_NTOHL (0x61626c65), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0 + 20, + ACE_NTOHL (0x456e7669), + ACE_NTOHL (0x726f6e6d), + ACE_NTOHL (0x656e7456), + ACE_NTOHL (0x61726961), + ACE_NTOHL (0x626c6500), // name = EnvironmentVariable + 2, // member count + 5, + ACE_NTOHL (0x6e616d65), + ACE_NTOHL (0x0), // name = name + CORBA::tk_string, + 0U, // string length + 6, + ACE_NTOHL (0x76616c75), + ACE_NTOHL (0x65000000), // name = value + CORBA::tk_string, + 0U, // string length + + 0U, + + + 18, + ACE_NTOHL (0x776f726b), + ACE_NTOHL (0x696e675f), + ACE_NTOHL (0x64697265), + ACE_NTOHL (0x63746f72), + ACE_NTOHL (0x79000000), // name = working_directory + CORBA::tk_string, + 0U, // string length + 11, + ACE_NTOHL (0x61637469), + ACE_NTOHL (0x76617469), + ACE_NTOHL (0x6f6e0000), // name = activation + CORBA::tk_enum, // typecode kind + 136, // encapsulation length +TAO_ENCAP_BYTE_ORDER, // byte order + 48, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f416374), + ACE_NTOHL (0x69766174), + ACE_NTOHL (0x696f6e4d), + ACE_NTOHL (0x6f64653a), + ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/ActivationMode:1.0 + 15, + ACE_NTOHL (0x41637469), + ACE_NTOHL (0x76617469), + ACE_NTOHL (0x6f6e4d6f), + ACE_NTOHL (0x64650000), // name = ActivationMode + 4, // member count + 7, + ACE_NTOHL (0x4e4f524d), + ACE_NTOHL (0x414c0000), // name = NORMAL + 7, + ACE_NTOHL (0x4d414e55), + ACE_NTOHL (0x414c0000), // name = MANUAL + 11, + ACE_NTOHL (0x5045525f), + ACE_NTOHL (0x434c4945), + ACE_NTOHL (0x4e540000), // name = PER_CLIENT + 11, + ACE_NTOHL (0x4155544f), + ACE_NTOHL (0x5f535441), + ACE_NTOHL (0x52540000), // name = AUTO_START + + 10, + ACE_NTOHL (0x61637469), + ACE_NTOHL (0x7661746f), + ACE_NTOHL (0x72000000), // name = activator + CORBA::tk_string, + 0U, // string length + 12, + ACE_NTOHL (0x73746172), + ACE_NTOHL (0x745f6c69), + ACE_NTOHL (0x6d697400), // name = start_limit + CORBA::tk_long, + + + 12, + ACE_NTOHL (0x70617274), + ACE_NTOHL (0x69616c5f), + ACE_NTOHL (0x696f7200), // name = partial_ior + CORBA::tk_string, + 0U, // string length +}; + +static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerInformation ( + CORBA::tk_struct, + sizeof (_oc_ImplementationRepository_ServerInformation), + (char *) &_oc_ImplementationRepository_ServerInformation, + 0, + 0 + ); + +namespace ImplementationRepository +{ + ::CORBA::TypeCode_ptr _tc_ServerInformation = + &_tc_TAO_tc_ImplementationRepository_ServerInformation; +} + +// TAO_IDL - Generated from +// be\be_visitor_typecode/typecode_defn.cpp:295 + +static const CORBA::Long _oc_ImplementationRepository_ServerInformationList[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 55, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f536572), + ACE_NTOHL (0x76657249), + ACE_NTOHL (0x6e666f72), + ACE_NTOHL (0x6d617469), + ACE_NTOHL (0x6f6e4c69), + ACE_NTOHL (0x73743a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:ImplementationRepository/ServerInformationList:1.0 + 22, + ACE_NTOHL (0x53657276), + ACE_NTOHL (0x6572496e), + ACE_NTOHL (0x666f726d), + ACE_NTOHL (0x6174696f), + ACE_NTOHL (0x6e4c6973), + ACE_NTOHL (0x74000000), // name = ServerInformationList + CORBA::tk_sequence, // typecode kind + 772, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + CORBA::tk_struct, // typecode kind + 756, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 51, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f536572), + ACE_NTOHL (0x76657249), + ACE_NTOHL (0x6e666f72), + ACE_NTOHL (0x6d617469), + ACE_NTOHL (0x6f6e3a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:ImplementationRepository/ServerInformation:1.0 + 18, + ACE_NTOHL (0x53657276), + ACE_NTOHL (0x6572496e), + ACE_NTOHL (0x666f726d), + ACE_NTOHL (0x6174696f), + ACE_NTOHL (0x6e000000), // name = ServerInformation + 3, // member count + 7, + ACE_NTOHL (0x73657276), + ACE_NTOHL (0x65720000), // name = server + CORBA::tk_string, + 0U, // string length + 8, + ACE_NTOHL (0x73746172), + ACE_NTOHL (0x74757000), // name = startup + CORBA::tk_struct, // typecode kind + 604, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 48, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f537461), + ACE_NTOHL (0x72747570), + ACE_NTOHL (0x4f707469), + ACE_NTOHL (0x6f6e733a), + ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/StartupOptions:1.0 + 15, + ACE_NTOHL (0x53746172), + ACE_NTOHL (0x7475704f), + ACE_NTOHL (0x7074696f), + ACE_NTOHL (0x6e730000), // name = StartupOptions + 6, // member count + 13, + ACE_NTOHL (0x636f6d6d), + ACE_NTOHL (0x616e645f), + ACE_NTOHL (0x6c696e65), + ACE_NTOHL (0x0), // name = command_line + CORBA::tk_string, + 0U, // string length + 12, + ACE_NTOHL (0x656e7669), + ACE_NTOHL (0x726f6e6d), + ACE_NTOHL (0x656e7400), // name = environment + CORBA::tk_alias, // typecode kind for typedefs + 236, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 49, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f456e76), + ACE_NTOHL (0x69726f6e), + ACE_NTOHL (0x6d656e74), + ACE_NTOHL (0x4c697374), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentList:1.0 + 16, + ACE_NTOHL (0x456e7669), + ACE_NTOHL (0x726f6e6d), + ACE_NTOHL (0x656e744c), + ACE_NTOHL (0x69737400), // name = EnvironmentList + CORBA::tk_sequence, // typecode kind + 148, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + CORBA::tk_struct, // typecode kind + 132, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 53, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f456e76), + ACE_NTOHL (0x69726f6e), + ACE_NTOHL (0x6d656e74), + ACE_NTOHL (0x56617269), + ACE_NTOHL (0x61626c65), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0 + 20, + ACE_NTOHL (0x456e7669), + ACE_NTOHL (0x726f6e6d), + ACE_NTOHL (0x656e7456), + ACE_NTOHL (0x61726961), + ACE_NTOHL (0x626c6500), // name = EnvironmentVariable + 2, // member count + 5, + ACE_NTOHL (0x6e616d65), + ACE_NTOHL (0x0), // name = name + CORBA::tk_string, + 0U, // string length + 6, + ACE_NTOHL (0x76616c75), + ACE_NTOHL (0x65000000), // name = value + CORBA::tk_string, + 0U, // string length + + 0U, + + + 18, + ACE_NTOHL (0x776f726b), + ACE_NTOHL (0x696e675f), + ACE_NTOHL (0x64697265), + ACE_NTOHL (0x63746f72), + ACE_NTOHL (0x79000000), // name = working_directory + CORBA::tk_string, + 0U, // string length + 11, + ACE_NTOHL (0x61637469), + ACE_NTOHL (0x76617469), + ACE_NTOHL (0x6f6e0000), // name = activation + CORBA::tk_enum, // typecode kind + 136, // encapsulation length +TAO_ENCAP_BYTE_ORDER, // byte order + 48, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f416374), + ACE_NTOHL (0x69766174), + ACE_NTOHL (0x696f6e4d), + ACE_NTOHL (0x6f64653a), + ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/ActivationMode:1.0 + 15, + ACE_NTOHL (0x41637469), + ACE_NTOHL (0x76617469), + ACE_NTOHL (0x6f6e4d6f), + ACE_NTOHL (0x64650000), // name = ActivationMode + 4, // member count + 7, + ACE_NTOHL (0x4e4f524d), + ACE_NTOHL (0x414c0000), // name = NORMAL + 7, + ACE_NTOHL (0x4d414e55), + ACE_NTOHL (0x414c0000), // name = MANUAL + 11, + ACE_NTOHL (0x5045525f), + ACE_NTOHL (0x434c4945), + ACE_NTOHL (0x4e540000), // name = PER_CLIENT + 11, + ACE_NTOHL (0x4155544f), + ACE_NTOHL (0x5f535441), + ACE_NTOHL (0x52540000), // name = AUTO_START + + 10, + ACE_NTOHL (0x61637469), + ACE_NTOHL (0x7661746f), + ACE_NTOHL (0x72000000), // name = activator + CORBA::tk_string, + 0U, // string length + 12, + ACE_NTOHL (0x73746172), + ACE_NTOHL (0x745f6c69), + ACE_NTOHL (0x6d697400), // name = start_limit + CORBA::tk_long, + + + 12, + ACE_NTOHL (0x70617274), + ACE_NTOHL (0x69616c5f), + ACE_NTOHL (0x696f7200), // name = partial_ior + CORBA::tk_string, + 0U, // string length + + 0U, + +}; + +static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerInformationList ( + CORBA::tk_alias, + sizeof (_oc_ImplementationRepository_ServerInformationList), + (char *) &_oc_ImplementationRepository_ServerInformationList, + 0, + 0 + ); + +namespace ImplementationRepository +{ + ::CORBA::TypeCode_ptr _tc_ServerInformationList = + &_tc_TAO_tc_ImplementationRepository_ServerInformationList; +} + +// TAO_IDL - Generated from +// be\be_visitor_typecode/typecode_defn.cpp:295 + +static const CORBA::Long _oc_ImplementationRepository_ServerInformationIterator[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 59, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f536572), + ACE_NTOHL (0x76657249), + ACE_NTOHL (0x6e666f72), + ACE_NTOHL (0x6d617469), + ACE_NTOHL (0x6f6e4974), + ACE_NTOHL (0x65726174), + ACE_NTOHL (0x6f723a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:ImplementationRepository/ServerInformationIterator:1.0 + 26, + ACE_NTOHL (0x53657276), + ACE_NTOHL (0x6572496e), + ACE_NTOHL (0x666f726d), + ACE_NTOHL (0x6174696f), + ACE_NTOHL (0x6e497465), + ACE_NTOHL (0x7261746f), + ACE_NTOHL (0x72000000), // name = ServerInformationIterator + }; + +static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerInformationIterator ( + CORBA::tk_objref, + sizeof (_oc_ImplementationRepository_ServerInformationIterator), + (char *) &_oc_ImplementationRepository_ServerInformationIterator, + 0, + 0 + ); + +namespace ImplementationRepository +{ + ::CORBA::TypeCode_ptr _tc_ServerInformationIterator = + &_tc_TAO_tc_ImplementationRepository_ServerInformationIterator; +} + +// TAO_IDL - Generated from +// be\be_visitor_typecode/typecode_defn.cpp:295 + +static const CORBA::Long _oc_ImplementationRepository_Administration[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 48, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f41646d), + ACE_NTOHL (0x696e6973), + ACE_NTOHL (0x74726174), + ACE_NTOHL (0x696f6e3a), + ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/Administration:1.0 + 15, + ACE_NTOHL (0x41646d69), + ACE_NTOHL (0x6e697374), + ACE_NTOHL (0x72617469), + ACE_NTOHL (0x6f6e0000), // name = Administration + }; + +static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Administration ( + CORBA::tk_objref, + sizeof (_oc_ImplementationRepository_Administration), + (char *) &_oc_ImplementationRepository_Administration, + 0, + 0 + ); + +namespace ImplementationRepository +{ + ::CORBA::TypeCode_ptr _tc_Administration = + &_tc_TAO_tc_ImplementationRepository_Administration; +} + +// TAO_IDL - Generated from +// be\be_visitor_exception/any_op_cs.cpp:50 + +ACE_TEMPLATE_SPECIALIZATION +CORBA::Boolean +TAO::Any_Dual_Impl_T<ImplementationRepository::AlreadyRegistered>::demarshal_value ( + TAO_InputCDR & cdr + ) +{ + CORBA::String_var id; + + if (!(cdr >> id.out ())) + { + return false; + } + + ACE_TRY_NEW_ENV + { + this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + return false; + } + ACE_ENDTRY; + + return true; +} + +// Copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + const ImplementationRepository::AlreadyRegistered &_tao_elem + ) +{ + TAO::Any_Dual_Impl_T<ImplementationRepository::AlreadyRegistered>::insert_copy ( + _tao_any, + ImplementationRepository::AlreadyRegistered::_tao_any_destructor, + ImplementationRepository::_tc_AlreadyRegistered, + _tao_elem + ); +} + +// Non-copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + ImplementationRepository::AlreadyRegistered *_tao_elem + ) +{ + TAO::Any_Dual_Impl_T<ImplementationRepository::AlreadyRegistered>::insert ( + _tao_any, + ImplementationRepository::AlreadyRegistered::_tao_any_destructor, + ImplementationRepository::_tc_AlreadyRegistered, + _tao_elem + ); +} + +// Extraction to non-const pointer (deprecated). +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + ImplementationRepository::AlreadyRegistered *&_tao_elem + ) +{ + return _tao_any >>= const_cast< + const ImplementationRepository::AlreadyRegistered *&> ( + _tao_elem + ); +} + +// Extraction to const pointer. +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + const ImplementationRepository::AlreadyRegistered *&_tao_elem + ) +{ + return + TAO::Any_Dual_Impl_T<ImplementationRepository::AlreadyRegistered>::extract ( + _tao_any, + ImplementationRepository::AlreadyRegistered::_tao_any_destructor, + ImplementationRepository::_tc_AlreadyRegistered, + _tao_elem + ); +} + +// TAO_IDL - Generated from +// be\be_visitor_exception/any_op_cs.cpp:50 + +ACE_TEMPLATE_SPECIALIZATION +CORBA::Boolean +TAO::Any_Dual_Impl_T<ImplementationRepository::CannotActivate>::demarshal_value ( + TAO_InputCDR & cdr + ) +{ + CORBA::String_var id; + + if (!(cdr >> id.out ())) + { + return false; + } + + ACE_TRY_NEW_ENV + { + this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + return false; + } + ACE_ENDTRY; + + return true; +} + +// Copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + const ImplementationRepository::CannotActivate &_tao_elem + ) +{ + TAO::Any_Dual_Impl_T<ImplementationRepository::CannotActivate>::insert_copy ( + _tao_any, + ImplementationRepository::CannotActivate::_tao_any_destructor, + ImplementationRepository::_tc_CannotActivate, + _tao_elem + ); +} + +// Non-copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + ImplementationRepository::CannotActivate *_tao_elem + ) +{ + TAO::Any_Dual_Impl_T<ImplementationRepository::CannotActivate>::insert ( + _tao_any, + ImplementationRepository::CannotActivate::_tao_any_destructor, + ImplementationRepository::_tc_CannotActivate, + _tao_elem + ); +} + +// Extraction to non-const pointer (deprecated). +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + ImplementationRepository::CannotActivate *&_tao_elem + ) +{ + return _tao_any >>= const_cast< + const ImplementationRepository::CannotActivate *&> ( + _tao_elem + ); +} + +// Extraction to const pointer. +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + const ImplementationRepository::CannotActivate *&_tao_elem + ) +{ + return + TAO::Any_Dual_Impl_T<ImplementationRepository::CannotActivate>::extract ( + _tao_any, + ImplementationRepository::CannotActivate::_tao_any_destructor, + ImplementationRepository::_tc_CannotActivate, + _tao_elem + ); +} + +// TAO_IDL - Generated from +// be\be_visitor_exception/any_op_cs.cpp:50 + +ACE_TEMPLATE_SPECIALIZATION +CORBA::Boolean +TAO::Any_Dual_Impl_T<ImplementationRepository::NotFound>::demarshal_value ( + TAO_InputCDR & cdr + ) +{ + CORBA::String_var id; + + if (!(cdr >> id.out ())) + { + return false; + } + + ACE_TRY_NEW_ENV + { + this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + return false; + } + ACE_ENDTRY; + + return true; +} + +// Copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + const ImplementationRepository::NotFound &_tao_elem + ) +{ + TAO::Any_Dual_Impl_T<ImplementationRepository::NotFound>::insert_copy ( + _tao_any, + ImplementationRepository::NotFound::_tao_any_destructor, + ImplementationRepository::_tc_NotFound, + _tao_elem + ); +} + +// Non-copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + ImplementationRepository::NotFound *_tao_elem + ) +{ + TAO::Any_Dual_Impl_T<ImplementationRepository::NotFound>::insert ( + _tao_any, + ImplementationRepository::NotFound::_tao_any_destructor, + ImplementationRepository::_tc_NotFound, + _tao_elem + ); +} + +// Extraction to non-const pointer (deprecated). +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + ImplementationRepository::NotFound *&_tao_elem + ) +{ + return _tao_any >>= const_cast< + const ImplementationRepository::NotFound *&> ( + _tao_elem + ); +} + +// Extraction to const pointer. +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + const ImplementationRepository::NotFound *&_tao_elem + ) +{ + return + TAO::Any_Dual_Impl_T<ImplementationRepository::NotFound>::extract ( + _tao_any, + ImplementationRepository::NotFound::_tao_any_destructor, + ImplementationRepository::_tc_NotFound, + _tao_elem + ); +} + +// TAO_IDL - Generated from +// be\be_visitor_structure/any_op_cs.cpp:54 + +// Copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + const ImplementationRepository::EnvironmentVariable &_tao_elem + ) +{ + TAO::Any_Dual_Impl_T<ImplementationRepository::EnvironmentVariable>::insert_copy ( + _tao_any, + ImplementationRepository::EnvironmentVariable::_tao_any_destructor, + ImplementationRepository::_tc_EnvironmentVariable, + _tao_elem + ); +} + +// Non-copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + ImplementationRepository::EnvironmentVariable *_tao_elem + ) +{ + TAO::Any_Dual_Impl_T<ImplementationRepository::EnvironmentVariable>::insert ( + _tao_any, + ImplementationRepository::EnvironmentVariable::_tao_any_destructor, + ImplementationRepository::_tc_EnvironmentVariable, + _tao_elem + ); +} + +// Extraction to non-const pointer (deprecated). +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + ImplementationRepository::EnvironmentVariable *&_tao_elem + ) +{ + return _tao_any >>= const_cast< + const ImplementationRepository::EnvironmentVariable *&> ( + _tao_elem + ); +} + +// Extraction to const pointer. +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + const ImplementationRepository::EnvironmentVariable *&_tao_elem + ) +{ + return + TAO::Any_Dual_Impl_T<ImplementationRepository::EnvironmentVariable>::extract ( + _tao_any, + ImplementationRepository::EnvironmentVariable::_tao_any_destructor, + ImplementationRepository::_tc_EnvironmentVariable, + _tao_elem + ); +} + +// TAO_IDL - Generated from +// be\be_visitor_sequence/any_op_cs.cpp:54 + +// Copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + const ImplementationRepository::EnvironmentList &_tao_elem + ) +{ + TAO::Any_Dual_Impl_T<ImplementationRepository::EnvironmentList>::insert_copy ( + _tao_any, + ImplementationRepository::EnvironmentList::_tao_any_destructor, + ImplementationRepository::_tc_EnvironmentList, + _tao_elem + ); +} + +// Non-copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + ImplementationRepository::EnvironmentList *_tao_elem + ) +{ + TAO::Any_Dual_Impl_T<ImplementationRepository::EnvironmentList>::insert ( + _tao_any, + ImplementationRepository::EnvironmentList::_tao_any_destructor, + ImplementationRepository::_tc_EnvironmentList, + _tao_elem + ); +} + +// Extraction to non-const pointer (deprecated). +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + ImplementationRepository::EnvironmentList *&_tao_elem + ) +{ + return _tao_any >>= const_cast< + const ImplementationRepository::EnvironmentList *&> ( + _tao_elem + ); +} + +// Extraction to const pointer. +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + const ImplementationRepository::EnvironmentList *&_tao_elem + ) +{ + return + TAO::Any_Dual_Impl_T<ImplementationRepository::EnvironmentList>::extract ( + _tao_any, + ImplementationRepository::EnvironmentList::_tao_any_destructor, + ImplementationRepository::_tc_EnvironmentList, + _tao_elem + ); +} + +// TAO_IDL - Generated from +// be\be_visitor_enum/any_op_cs.cpp:52 + +void operator<<= ( + CORBA::Any &_tao_any, + ImplementationRepository::ActivationMode _tao_elem + ) +{ + TAO::Any_Basic_Impl_T<ImplementationRepository::ActivationMode>::insert ( + _tao_any, + ImplementationRepository::_tc_ActivationMode, + _tao_elem + ); +} + +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + ImplementationRepository::ActivationMode &_tao_elem + ) +{ + return + TAO::Any_Basic_Impl_T<ImplementationRepository::ActivationMode>::extract ( + _tao_any, + ImplementationRepository::_tc_ActivationMode, + _tao_elem + ); +} + +// TAO_IDL - Generated from +// be\be_visitor_structure/any_op_cs.cpp:54 + +// Copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + const ImplementationRepository::StartupOptions &_tao_elem + ) +{ + TAO::Any_Dual_Impl_T<ImplementationRepository::StartupOptions>::insert_copy ( + _tao_any, + ImplementationRepository::StartupOptions::_tao_any_destructor, + ImplementationRepository::_tc_StartupOptions, + _tao_elem + ); +} + +// Non-copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + ImplementationRepository::StartupOptions *_tao_elem + ) +{ + TAO::Any_Dual_Impl_T<ImplementationRepository::StartupOptions>::insert ( + _tao_any, + ImplementationRepository::StartupOptions::_tao_any_destructor, + ImplementationRepository::_tc_StartupOptions, + _tao_elem + ); +} + +// Extraction to non-const pointer (deprecated). +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + ImplementationRepository::StartupOptions *&_tao_elem + ) +{ + return _tao_any >>= const_cast< + const ImplementationRepository::StartupOptions *&> ( + _tao_elem + ); +} + +// Extraction to const pointer. +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + const ImplementationRepository::StartupOptions *&_tao_elem + ) +{ + return + TAO::Any_Dual_Impl_T<ImplementationRepository::StartupOptions>::extract ( + _tao_any, + ImplementationRepository::StartupOptions::_tao_any_destructor, + ImplementationRepository::_tc_StartupOptions, + _tao_elem + ); +} + +// TAO_IDL - Generated from +// be\be_visitor_structure/any_op_cs.cpp:54 + +// Copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + const ImplementationRepository::ServerInformation &_tao_elem + ) +{ + TAO::Any_Dual_Impl_T<ImplementationRepository::ServerInformation>::insert_copy ( + _tao_any, + ImplementationRepository::ServerInformation::_tao_any_destructor, + ImplementationRepository::_tc_ServerInformation, + _tao_elem + ); +} + +// Non-copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + ImplementationRepository::ServerInformation *_tao_elem + ) +{ + TAO::Any_Dual_Impl_T<ImplementationRepository::ServerInformation>::insert ( + _tao_any, + ImplementationRepository::ServerInformation::_tao_any_destructor, + ImplementationRepository::_tc_ServerInformation, + _tao_elem + ); +} + +// Extraction to non-const pointer (deprecated). +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + ImplementationRepository::ServerInformation *&_tao_elem + ) +{ + return _tao_any >>= const_cast< + const ImplementationRepository::ServerInformation *&> ( + _tao_elem + ); +} + +// Extraction to const pointer. +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + const ImplementationRepository::ServerInformation *&_tao_elem + ) +{ + return + TAO::Any_Dual_Impl_T<ImplementationRepository::ServerInformation>::extract ( + _tao_any, + ImplementationRepository::ServerInformation::_tao_any_destructor, + ImplementationRepository::_tc_ServerInformation, + _tao_elem + ); +} + +// TAO_IDL - Generated from +// be\be_visitor_sequence/any_op_cs.cpp:54 + +// Copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + const ImplementationRepository::ServerInformationList &_tao_elem + ) +{ + TAO::Any_Dual_Impl_T<ImplementationRepository::ServerInformationList>::insert_copy ( + _tao_any, + ImplementationRepository::ServerInformationList::_tao_any_destructor, + ImplementationRepository::_tc_ServerInformationList, + _tao_elem + ); +} + +// Non-copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + ImplementationRepository::ServerInformationList *_tao_elem + ) +{ + TAO::Any_Dual_Impl_T<ImplementationRepository::ServerInformationList>::insert ( + _tao_any, + ImplementationRepository::ServerInformationList::_tao_any_destructor, + ImplementationRepository::_tc_ServerInformationList, + _tao_elem + ); +} + +// Extraction to non-const pointer (deprecated). +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + ImplementationRepository::ServerInformationList *&_tao_elem + ) +{ + return _tao_any >>= const_cast< + const ImplementationRepository::ServerInformationList *&> ( + _tao_elem + ); +} + +// Extraction to const pointer. +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + const ImplementationRepository::ServerInformationList *&_tao_elem + ) +{ + return + TAO::Any_Dual_Impl_T<ImplementationRepository::ServerInformationList>::extract ( + _tao_any, + ImplementationRepository::ServerInformationList::_tao_any_destructor, + ImplementationRepository::_tc_ServerInformationList, + _tao_elem + ); +} + +// TAO_IDL - Generated from +// be\be_visitor_interface/any_op_cs.cpp:50 + +ACE_TEMPLATE_SPECIALIZATION +CORBA::Boolean +TAO::Any_Impl_T<ImplementationRepository::ServerInformationIterator>::to_object ( + CORBA::Object_ptr &_tao_elem + ) const +{ + _tao_elem = CORBA::Object::_duplicate (this->value_); + return 1; +} + +// Copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + ImplementationRepository::ServerInformationIterator_ptr _tao_elem + ) +{ + ImplementationRepository::ServerInformationIterator_ptr _tao_objptr = + ImplementationRepository::ServerInformationIterator::_duplicate (_tao_elem); + _tao_any <<= &_tao_objptr; +} + +// Non-copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + ImplementationRepository::ServerInformationIterator_ptr *_tao_elem + ) +{ + TAO::Any_Impl_T<ImplementationRepository::ServerInformationIterator>::insert ( + _tao_any, + ImplementationRepository::ServerInformationIterator::_tao_any_destructor, + ImplementationRepository::_tc_ServerInformationIterator, + *_tao_elem + ); +} + +CORBA::Boolean +operator>>= ( + const CORBA::Any &_tao_any, + ImplementationRepository::ServerInformationIterator_ptr &_tao_elem + ) +{ + return + TAO::Any_Impl_T<ImplementationRepository::ServerInformationIterator>::extract ( + _tao_any, + ImplementationRepository::ServerInformationIterator::_tao_any_destructor, + ImplementationRepository::_tc_ServerInformationIterator, + _tao_elem + ); +} + +// TAO_IDL - Generated from +// be\be_visitor_interface/any_op_cs.cpp:50 + +ACE_TEMPLATE_SPECIALIZATION +CORBA::Boolean +TAO::Any_Impl_T<ImplementationRepository::Administration>::to_object ( + CORBA::Object_ptr &_tao_elem + ) const +{ + _tao_elem = CORBA::Object::_duplicate (this->value_); + return 1; +} + +// Copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + ImplementationRepository::Administration_ptr _tao_elem + ) +{ + ImplementationRepository::Administration_ptr _tao_objptr = + ImplementationRepository::Administration::_duplicate (_tao_elem); + _tao_any <<= &_tao_objptr; +} + +// Non-copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + ImplementationRepository::Administration_ptr *_tao_elem + ) +{ + TAO::Any_Impl_T<ImplementationRepository::Administration>::insert ( + _tao_any, + ImplementationRepository::Administration::_tao_any_destructor, + ImplementationRepository::_tc_Administration, + *_tao_elem + ); +} + +CORBA::Boolean +operator>>= ( + const CORBA::Any &_tao_any, + ImplementationRepository::Administration_ptr &_tao_elem + ) +{ + return + TAO::Any_Impl_T<ImplementationRepository::Administration>::extract ( + _tao_any, + ImplementationRepository::Administration::_tao_any_destructor, + ImplementationRepository::_tc_Administration, + _tao_elem + ); +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + + template class + TAO::Any_Dual_Impl_T< + ImplementationRepository::AlreadyRegistered + >; + + template class + TAO::Any_Dual_Impl_T< + ImplementationRepository::CannotActivate + >; + + template class + TAO::Any_Dual_Impl_T< + ImplementationRepository::NotFound + >; + + template class + TAO::Any_Dual_Impl_T< + ImplementationRepository::EnvironmentVariable + >; + + template class + TAO::Any_Dual_Impl_T< + ImplementationRepository::EnvironmentList + >; + + template class + TAO::Any_Basic_Impl_T< + ImplementationRepository::ActivationMode + >; + + template class + TAO::Any_Dual_Impl_T< + ImplementationRepository::StartupOptions + >; + + template class + TAO::Any_Dual_Impl_T< + ImplementationRepository::ServerInformation + >; + + template class + TAO::Any_Dual_Impl_T< + ImplementationRepository::ServerInformationList + >; + + template class + TAO::Any_Impl_T< + ImplementationRepository::ServerInformationIterator + >; + + template class + TAO::Any_Impl_T< + ImplementationRepository::Administration + >; + +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + +# pragma instantiate \ + TAO::Any_Dual_Impl_T< \ + ImplementationRepository::AlreadyRegistered \ + > + +# pragma instantiate \ + TAO::Any_Dual_Impl_T< \ + ImplementationRepository::CannotActivate \ + > + +# pragma instantiate \ + TAO::Any_Dual_Impl_T< \ + ImplementationRepository::NotFound \ + > + +# pragma instantiate \ + TAO::Any_Dual_Impl_T< \ + ImplementationRepository::EnvironmentVariable \ + > + +# pragma instantiate \ + TAO::Any_Dual_Impl_T< \ + ImplementationRepository::EnvironmentList \ + > + +# pragma instantiate \ + TAO::Any_Basic_Impl_T< \ + ImplementationRepository::ActivationMode \ + > + +# pragma instantiate \ + TAO::Any_Dual_Impl_T< \ + ImplementationRepository::StartupOptions \ + > + +# pragma instantiate \ + TAO::Any_Dual_Impl_T< \ + ImplementationRepository::ServerInformation \ + > + +# pragma instantiate \ + TAO::Any_Dual_Impl_T< \ + ImplementationRepository::ServerInformationList \ + > + +# pragma instantiate \ + TAO::Any_Impl_T< \ + ImplementationRepository::ServerInformationIterator \ + > + +# pragma instantiate \ + TAO::Any_Impl_T< \ + ImplementationRepository::Administration \ + > + +#endif /* !ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ diff --git a/TAO/tao/ImR_Client/ImplRepoC.cpp b/TAO/tao/ImR_Client/ImplRepoC.cpp new file mode 100644 index 00000000000..741bb0a51d5 --- /dev/null +++ b/TAO/tao/ImR_Client/ImplRepoC.cpp @@ -0,0 +1,2603 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// and +// Institute for Software Integrated Systems +// Vanderbilt University +// Nashville, TN +// USA +// http://www.isis.vanderbilt.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +// TAO_IDL - Generated from +// be\be_codegen.cpp:302 + + +#include "ImplRepoC.h" +#include "tao/CDR.h" +#include "tao/Exception_Data.h" +#include "tao/Invocation_Adapter.h" +#include "tao/Object_T.h" +#include "tao/Typecode.h" +#include "tao/Basic_Arguments.h" +#include "tao/Object_Argument_T.h" +#include "tao/Special_Basic_Arguments.h" +#include "tao/UB_String_Arguments.h" +#include "tao/Var_Size_Argument_T.h" +#include "ace/OS_NS_string.h" + +#if defined (__BORLANDC__) +#pragma option -w-rvl -w-rch -w-ccc -w-aus -w-sig +#endif /* __BORLANDC__ */ + +#if !defined (__ACE_INLINE__) +#include "ImplRepoC.inl" +#endif /* !defined INLINE */ + +// TAO_IDL - Generated from +// be\be_visitor_arg_traits.cpp:66 + +// Arg traits specializations. +namespace TAO +{ + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVEROBJECT__ARG_TRAITS_CS_) +#define _IMPLEMENTATIONREPOSITORY_SERVEROBJECT__ARG_TRAITS_CS_ + + ACE_TEMPLATE_SPECIALIZATION + class TAO_IMR_Client_Export Arg_Traits<ImplementationRepository::ServerObject> + : public + Object_Arg_Traits_T< + ImplementationRepository::ServerObject_ptr, + ImplementationRepository::ServerObject_var, + ImplementationRepository::ServerObject_out, + TAO::Objref_Traits<ImplementationRepository::ServerObject> + > + { + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be\be_visitor_arg_traits.cpp:662 + +#if !defined (_IMPLEMENTATIONREPOSITORY_STARTUPOPTIONS__ARG_TRAITS_CS_) +#define _IMPLEMENTATIONREPOSITORY_STARTUPOPTIONS__ARG_TRAITS_CS_ + + ACE_TEMPLATE_SPECIALIZATION + class TAO_IMR_Client_Export Arg_Traits<ImplementationRepository::StartupOptions> + : public + Var_Size_Arg_Traits_T< + ImplementationRepository::StartupOptions, + ImplementationRepository::StartupOptions_var, + ImplementationRepository::StartupOptions_out + > + { + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be\be_visitor_arg_traits.cpp:662 + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATION__ARG_TRAITS_CS_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATION__ARG_TRAITS_CS_ + + ACE_TEMPLATE_SPECIALIZATION + class TAO_IMR_Client_Export Arg_Traits<ImplementationRepository::ServerInformation> + : public + Var_Size_Arg_Traits_T< + ImplementationRepository::ServerInformation, + ImplementationRepository::ServerInformation_var, + ImplementationRepository::ServerInformation_out + > + { + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be\be_visitor_arg_traits.cpp:433 + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST__ARG_TRAITS_CS_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST__ARG_TRAITS_CS_ + + ACE_TEMPLATE_SPECIALIZATION + class TAO_IMR_Client_Export Arg_Traits<ImplementationRepository::ServerInformationList> + : public + Var_Size_Arg_Traits_T< + ImplementationRepository::ServerInformationList, + ImplementationRepository::ServerInformationList_var, + ImplementationRepository::ServerInformationList_out + > + { + }; + +#endif /* end #if !defined */ + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR__ARG_TRAITS_CS_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR__ARG_TRAITS_CS_ + + ACE_TEMPLATE_SPECIALIZATION + class TAO_IMR_Client_Export Arg_Traits<ImplementationRepository::ServerInformationIterator> + : public + Object_Arg_Traits_T< + ImplementationRepository::ServerInformationIterator_ptr, + ImplementationRepository::ServerInformationIterator_var, + ImplementationRepository::ServerInformationIterator_out, + TAO::Objref_Traits<ImplementationRepository::ServerInformationIterator> + > + { + }; + +#endif /* end #if !defined */ +} + + +// TAO_IDL - Generated from +// be\be_visitor_exception/exception_cs.cpp:63 + +ImplementationRepository::AlreadyRegistered::AlreadyRegistered (void) + : CORBA::UserException ( + "IDL:ImplementationRepository/AlreadyRegistered:1.0", + "AlreadyRegistered" + ) +{ +} + +ImplementationRepository::AlreadyRegistered::~AlreadyRegistered (void) +{ +} + +ImplementationRepository::AlreadyRegistered::AlreadyRegistered (const ::ImplementationRepository::AlreadyRegistered &_tao_excp) + : CORBA::UserException ( + _tao_excp._rep_id (), + _tao_excp._name () + ) +{ +} + +ImplementationRepository::AlreadyRegistered& +ImplementationRepository::AlreadyRegistered::operator= (const ::ImplementationRepository::AlreadyRegistered &_tao_excp) +{ + this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp); + return *this; +} + +void ImplementationRepository::AlreadyRegistered::_tao_any_destructor (void *_tao_void_pointer) +{ + AlreadyRegistered *_tao_tmp_pointer = + static_cast<AlreadyRegistered *> (_tao_void_pointer); + delete _tao_tmp_pointer; +} + +ImplementationRepository::AlreadyRegistered * +ImplementationRepository::AlreadyRegistered::_downcast (CORBA::Exception *_tao_excp) +{ + return dynamic_cast<AlreadyRegistered *> (_tao_excp); +} + +const ImplementationRepository::AlreadyRegistered * +ImplementationRepository::AlreadyRegistered::_downcast (CORBA::Exception const *_tao_excp) +{ + return dynamic_cast<const AlreadyRegistered *> (_tao_excp); +} + +CORBA::Exception *ImplementationRepository::AlreadyRegistered::_alloc (void) +{ + CORBA::Exception *retval = 0; + ACE_NEW_RETURN (retval, ::ImplementationRepository::AlreadyRegistered, 0); + return retval; +} + +CORBA::Exception * +ImplementationRepository::AlreadyRegistered::_tao_duplicate (void) const +{ + CORBA::Exception *result; + ACE_NEW_RETURN ( + result, + ::ImplementationRepository::AlreadyRegistered (*this), + 0 + ); + return result; +} + +void ImplementationRepository::AlreadyRegistered::_raise (void) const +{ + TAO_RAISE (*this); +} + +void ImplementationRepository::AlreadyRegistered::_tao_encode ( + TAO_OutputCDR &cdr + ACE_ENV_ARG_DECL + ) const +{ + if (cdr << *this) + { + return; + } + + ACE_THROW (CORBA::MARSHAL ()); +} + +void ImplementationRepository::AlreadyRegistered::_tao_decode ( + TAO_InputCDR &cdr + ACE_ENV_ARG_DECL + ) +{ + if (cdr >> *this) + { + return; + } + + ACE_THROW (CORBA::MARSHAL ()); +} + +// TAO extension - the virtual _type method. +CORBA::TypeCode_ptr ImplementationRepository::AlreadyRegistered::_type (void) const +{ + return ::ImplementationRepository::_tc_AlreadyRegistered; +} + +// TAO_IDL - Generated from +// be\be_visitor_typecode/typecode_defn.cpp:295 + +static const CORBA::Long _oc_ImplementationRepository_AlreadyRegistered[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 51, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f416c72), + ACE_NTOHL (0x65616479), + ACE_NTOHL (0x52656769), + ACE_NTOHL (0x73746572), + ACE_NTOHL (0x65643a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:ImplementationRepository/AlreadyRegistered:1.0 + 18, + ACE_NTOHL (0x416c7265), + ACE_NTOHL (0x61647952), + ACE_NTOHL (0x65676973), + ACE_NTOHL (0x74657265), + ACE_NTOHL (0x64000000), // name = AlreadyRegistered + 0, // member count + }; + +static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_AlreadyRegistered ( + CORBA::tk_except, + sizeof (_oc_ImplementationRepository_AlreadyRegistered), + (char *) &_oc_ImplementationRepository_AlreadyRegistered, + 0, + 0 + ); + +namespace ImplementationRepository +{ + ::CORBA::TypeCode_ptr _tc_AlreadyRegistered = + &_tc_TAO_tc_ImplementationRepository_AlreadyRegistered; +} + +// TAO_IDL - Generated from +// be\be_visitor_exception/exception_cs.cpp:63 + +ImplementationRepository::CannotActivate::CannotActivate (void) + : CORBA::UserException ( + "IDL:ImplementationRepository/CannotActivate:1.0", + "CannotActivate" + ) +{ +} + +ImplementationRepository::CannotActivate::~CannotActivate (void) +{ +} + +ImplementationRepository::CannotActivate::CannotActivate (const ::ImplementationRepository::CannotActivate &_tao_excp) + : CORBA::UserException ( + _tao_excp._rep_id (), + _tao_excp._name () + ) +{ + this->reason = CORBA::string_dup (_tao_excp.reason.in ()); +} + +ImplementationRepository::CannotActivate& +ImplementationRepository::CannotActivate::operator= (const ::ImplementationRepository::CannotActivate &_tao_excp) +{ + this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp); + this->reason = CORBA::string_dup (_tao_excp.reason.in ()); + return *this; +} + +void ImplementationRepository::CannotActivate::_tao_any_destructor (void *_tao_void_pointer) +{ + CannotActivate *_tao_tmp_pointer = + static_cast<CannotActivate *> (_tao_void_pointer); + delete _tao_tmp_pointer; +} + +ImplementationRepository::CannotActivate * +ImplementationRepository::CannotActivate::_downcast (CORBA::Exception *_tao_excp) +{ + return dynamic_cast<CannotActivate *> (_tao_excp); +} + +const ImplementationRepository::CannotActivate * +ImplementationRepository::CannotActivate::_downcast (CORBA::Exception const *_tao_excp) +{ + return dynamic_cast<const CannotActivate *> (_tao_excp); +} + +CORBA::Exception *ImplementationRepository::CannotActivate::_alloc (void) +{ + CORBA::Exception *retval = 0; + ACE_NEW_RETURN (retval, ::ImplementationRepository::CannotActivate, 0); + return retval; +} + +CORBA::Exception * +ImplementationRepository::CannotActivate::_tao_duplicate (void) const +{ + CORBA::Exception *result; + ACE_NEW_RETURN ( + result, + ::ImplementationRepository::CannotActivate (*this), + 0 + ); + return result; +} + +void ImplementationRepository::CannotActivate::_raise (void) const +{ + TAO_RAISE (*this); +} + +void ImplementationRepository::CannotActivate::_tao_encode ( + TAO_OutputCDR &cdr + ACE_ENV_ARG_DECL + ) const +{ + if (cdr << *this) + { + return; + } + + ACE_THROW (CORBA::MARSHAL ()); +} + +void ImplementationRepository::CannotActivate::_tao_decode ( + TAO_InputCDR &cdr + ACE_ENV_ARG_DECL + ) +{ + if (cdr >> *this) + { + return; + } + + ACE_THROW (CORBA::MARSHAL ()); +} + + + +// TAO_IDL - Generated from +// be\be_visitor_exception/exception_ctor.cpp:66 + +ImplementationRepository::CannotActivate::CannotActivate ( + const char * _tao_reason + ) + : CORBA::UserException ( + "IDL:ImplementationRepository/CannotActivate:1.0", + "CannotActivate" + ) +{ + this->reason = CORBA::string_dup (_tao_reason); +} + +// TAO extension - the virtual _type method. +CORBA::TypeCode_ptr ImplementationRepository::CannotActivate::_type (void) const +{ + return ::ImplementationRepository::_tc_CannotActivate; +} + +// TAO_IDL - Generated from +// be\be_visitor_typecode/typecode_defn.cpp:295 + +static const CORBA::Long _oc_ImplementationRepository_CannotActivate[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 48, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f43616e), + ACE_NTOHL (0x6e6f7441), + ACE_NTOHL (0x63746976), + ACE_NTOHL (0x6174653a), + ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/CannotActivate:1.0 + 15, + ACE_NTOHL (0x43616e6e), + ACE_NTOHL (0x6f744163), + ACE_NTOHL (0x74697661), + ACE_NTOHL (0x74650000), // name = CannotActivate + 1, // member count + 7, + ACE_NTOHL (0x72656173), + ACE_NTOHL (0x6f6e0000), // name = reason + CORBA::tk_string, + 0U, // string length +}; + +static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_CannotActivate ( + CORBA::tk_except, + sizeof (_oc_ImplementationRepository_CannotActivate), + (char *) &_oc_ImplementationRepository_CannotActivate, + 0, + 0 + ); + +namespace ImplementationRepository +{ + ::CORBA::TypeCode_ptr _tc_CannotActivate = + &_tc_TAO_tc_ImplementationRepository_CannotActivate; +} + +// TAO_IDL - Generated from +// be\be_visitor_exception/exception_cs.cpp:63 + +ImplementationRepository::NotFound::NotFound (void) + : CORBA::UserException ( + "IDL:ImplementationRepository/NotFound:1.0", + "NotFound" + ) +{ +} + +ImplementationRepository::NotFound::~NotFound (void) +{ +} + +ImplementationRepository::NotFound::NotFound (const ::ImplementationRepository::NotFound &_tao_excp) + : CORBA::UserException ( + _tao_excp._rep_id (), + _tao_excp._name () + ) +{ +} + +ImplementationRepository::NotFound& +ImplementationRepository::NotFound::operator= (const ::ImplementationRepository::NotFound &_tao_excp) +{ + this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp); + return *this; +} + +void ImplementationRepository::NotFound::_tao_any_destructor (void *_tao_void_pointer) +{ + NotFound *_tao_tmp_pointer = + static_cast<NotFound *> (_tao_void_pointer); + delete _tao_tmp_pointer; +} + +ImplementationRepository::NotFound * +ImplementationRepository::NotFound::_downcast (CORBA::Exception *_tao_excp) +{ + return dynamic_cast<NotFound *> (_tao_excp); +} + +const ImplementationRepository::NotFound * +ImplementationRepository::NotFound::_downcast (CORBA::Exception const *_tao_excp) +{ + return dynamic_cast<const NotFound *> (_tao_excp); +} + +CORBA::Exception *ImplementationRepository::NotFound::_alloc (void) +{ + CORBA::Exception *retval = 0; + ACE_NEW_RETURN (retval, ::ImplementationRepository::NotFound, 0); + return retval; +} + +CORBA::Exception * +ImplementationRepository::NotFound::_tao_duplicate (void) const +{ + CORBA::Exception *result; + ACE_NEW_RETURN ( + result, + ::ImplementationRepository::NotFound (*this), + 0 + ); + return result; +} + +void ImplementationRepository::NotFound::_raise (void) const +{ + TAO_RAISE (*this); +} + +void ImplementationRepository::NotFound::_tao_encode ( + TAO_OutputCDR &cdr + ACE_ENV_ARG_DECL + ) const +{ + if (cdr << *this) + { + return; + } + + ACE_THROW (CORBA::MARSHAL ()); +} + +void ImplementationRepository::NotFound::_tao_decode ( + TAO_InputCDR &cdr + ACE_ENV_ARG_DECL + ) +{ + if (cdr >> *this) + { + return; + } + + ACE_THROW (CORBA::MARSHAL ()); +} + +// TAO extension - the virtual _type method. +CORBA::TypeCode_ptr ImplementationRepository::NotFound::_type (void) const +{ + return ::ImplementationRepository::_tc_NotFound; +} + +// TAO_IDL - Generated from +// be\be_visitor_typecode/typecode_defn.cpp:295 + +static const CORBA::Long _oc_ImplementationRepository_NotFound[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 42, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f4e6f74), + ACE_NTOHL (0x466f756e), + ACE_NTOHL (0x643a312e), + ACE_NTOHL (0x30000000), // repository ID = IDL:ImplementationRepository/NotFound:1.0 + 9, + ACE_NTOHL (0x4e6f7446), + ACE_NTOHL (0x6f756e64), + ACE_NTOHL (0x0), // name = NotFound + 0, // member count + }; + +static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_NotFound ( + CORBA::tk_except, + sizeof (_oc_ImplementationRepository_NotFound), + (char *) &_oc_ImplementationRepository_NotFound, + 0, + 0 + ); + +namespace ImplementationRepository +{ + ::CORBA::TypeCode_ptr _tc_NotFound = + &_tc_TAO_tc_ImplementationRepository_NotFound; +} + +// TAO_IDL - Generated from +// be\be_visitor_structure/structure_cs.cpp:66 + +void +ImplementationRepository::EnvironmentVariable::_tao_any_destructor ( + void *_tao_void_pointer + ) +{ + EnvironmentVariable *_tao_tmp_pointer = + static_cast<EnvironmentVariable *> (_tao_void_pointer); + delete _tao_tmp_pointer; +} + +// TAO_IDL - Generated from +// be\be_visitor_sequence/sequence_cs.cpp:65 + +#if !defined (_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_) +#define _IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_ + +ImplementationRepository::EnvironmentList::EnvironmentList (void) +{} + +ImplementationRepository::EnvironmentList::EnvironmentList ( + CORBA::ULong max + ) + : TAO_Unbounded_Sequence< + ImplementationRepository::EnvironmentVariable + > + (max) +{} + +ImplementationRepository::EnvironmentList::EnvironmentList ( + CORBA::ULong max, + CORBA::ULong length, + ImplementationRepository::EnvironmentVariable * buffer, + CORBA::Boolean release + ) + : TAO_Unbounded_Sequence< + ImplementationRepository::EnvironmentVariable + > + (max, length, buffer, release) +{} + +ImplementationRepository::EnvironmentList::EnvironmentList ( + const EnvironmentList &seq + ) + : TAO_Unbounded_Sequence< + ImplementationRepository::EnvironmentVariable + > + (seq) +{} + +ImplementationRepository::EnvironmentList::~EnvironmentList (void) +{} + +void ImplementationRepository::EnvironmentList::_tao_any_destructor ( + void * _tao_void_pointer + ) +{ + EnvironmentList * _tao_tmp_pointer = + static_cast<EnvironmentList *> (_tao_void_pointer); + delete _tao_tmp_pointer; +} + +#endif /* end #if !defined */ + +// TAO_IDL - Generated from +// be\be_visitor_structure/structure_cs.cpp:66 + +void +ImplementationRepository::StartupOptions::_tao_any_destructor ( + void *_tao_void_pointer + ) +{ + StartupOptions *_tao_tmp_pointer = + static_cast<StartupOptions *> (_tao_void_pointer); + delete _tao_tmp_pointer; +} + +// TAO_IDL - Generated from +// be\be_visitor_structure/structure_cs.cpp:66 + +void +ImplementationRepository::ServerInformation::_tao_any_destructor ( + void *_tao_void_pointer + ) +{ + ServerInformation *_tao_tmp_pointer = + static_cast<ServerInformation *> (_tao_void_pointer); + delete _tao_tmp_pointer; +} + +// TAO_IDL - Generated from +// be\be_visitor_sequence/sequence_cs.cpp:65 + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_ + +ImplementationRepository::ServerInformationList::ServerInformationList (void) +{} + +ImplementationRepository::ServerInformationList::ServerInformationList ( + CORBA::ULong max + ) + : TAO_Unbounded_Sequence< + ImplementationRepository::ServerInformation + > + (max) +{} + +ImplementationRepository::ServerInformationList::ServerInformationList ( + CORBA::ULong max, + CORBA::ULong length, + ImplementationRepository::ServerInformation * buffer, + CORBA::Boolean release + ) + : TAO_Unbounded_Sequence< + ImplementationRepository::ServerInformation + > + (max, length, buffer, release) +{} + +ImplementationRepository::ServerInformationList::ServerInformationList ( + const ServerInformationList &seq + ) + : TAO_Unbounded_Sequence< + ImplementationRepository::ServerInformation + > + (seq) +{} + +ImplementationRepository::ServerInformationList::~ServerInformationList (void) +{} + +void ImplementationRepository::ServerInformationList::_tao_any_destructor ( + void * _tao_void_pointer + ) +{ + ServerInformationList * _tao_tmp_pointer = + static_cast<ServerInformationList *> (_tao_void_pointer); + delete _tao_tmp_pointer; +} + +#endif /* end #if !defined */ + +// TAO_IDL - Generated from +// be\be_visitor_interface/interface_cs.cpp:60 + +// Traits specializations for ImplementationRepository::ServerInformationIterator. + +ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION +ImplementationRepository::ServerInformationIterator_ptr +TAO::Objref_Traits<ImplementationRepository::ServerInformationIterator>::duplicate ( + ImplementationRepository::ServerInformationIterator_ptr p + ) +{ + return ImplementationRepository::ServerInformationIterator::_duplicate (p); +} + +ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION +void +TAO::Objref_Traits<ImplementationRepository::ServerInformationIterator>::release ( + ImplementationRepository::ServerInformationIterator_ptr p + ) +{ + CORBA::release (p); +} + +ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION +ImplementationRepository::ServerInformationIterator_ptr +TAO::Objref_Traits<ImplementationRepository::ServerInformationIterator>::nil (void) +{ + return ImplementationRepository::ServerInformationIterator::_nil (); +} + +ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION +CORBA::Boolean +TAO::Objref_Traits<ImplementationRepository::ServerInformationIterator>::marshal ( + ImplementationRepository::ServerInformationIterator_ptr p, + TAO_OutputCDR & cdr + ) +{ + return CORBA::Object::marshal (p, cdr); +} + +// Function pointer for collocation factory initialization. +TAO::Collocation_Proxy_Broker * +(*ImplementationRepository__TAO_ServerInformationIterator_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_cs.cpp:78 + +CORBA::Boolean ImplementationRepository::ServerInformationIterator::next_n ( + ::CORBA::ULong how_many, + ::ImplementationRepository::ServerInformationList_out servers + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + if (!this->is_evaluated ()) + { + ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this); + } + + if (this->the_TAO_ServerInformationIterator_Proxy_Broker_ == 0) + { + ImplementationRepository_ServerInformationIterator_setup_collocation (); + } + + TAO::Arg_Traits< ::ACE_InputCDR::to_boolean>::ret_val _tao_retval; + TAO::Arg_Traits< ::CORBA::ULong>::in_arg_val _tao_how_many (how_many); + TAO::Arg_Traits< ImplementationRepository::ServerInformationList>::out_arg_val _tao_servers (servers); + + TAO::Argument *_the_tao_operation_signature [] = + { + &_tao_retval, + &_tao_how_many, + &_tao_servers + }; + + TAO::Invocation_Adapter _tao_call ( + this, + _the_tao_operation_signature, + 3, + "next_n", + 6, + this->the_TAO_ServerInformationIterator_Proxy_Broker_ + ); + + _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (_tao_retval.excp ()); + + return _tao_retval.retn (); +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_cs.cpp:78 + +void ImplementationRepository::ServerInformationIterator::destroy ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + if (!this->is_evaluated ()) + { + ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this); + } + + if (this->the_TAO_ServerInformationIterator_Proxy_Broker_ == 0) + { + ImplementationRepository_ServerInformationIterator_setup_collocation (); + } + + TAO::Arg_Traits< void>::ret_val _tao_retval; + + TAO::Argument *_the_tao_operation_signature [] = + { + &_tao_retval + }; + + TAO::Invocation_Adapter _tao_call ( + this, + _the_tao_operation_signature, + 1, + "destroy", + 7, + this->the_TAO_ServerInformationIterator_Proxy_Broker_ + ); + + _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER); + ACE_CHECK; +} + +ImplementationRepository::ServerInformationIterator::ServerInformationIterator (void) + : the_TAO_ServerInformationIterator_Proxy_Broker_ (0) +{ + this->ImplementationRepository_ServerInformationIterator_setup_collocation (); +} + +void +ImplementationRepository::ServerInformationIterator::ImplementationRepository_ServerInformationIterator_setup_collocation () +{ + if (::ImplementationRepository__TAO_ServerInformationIterator_Proxy_Broker_Factory_function_pointer) + { + this->the_TAO_ServerInformationIterator_Proxy_Broker_ = + ::ImplementationRepository__TAO_ServerInformationIterator_Proxy_Broker_Factory_function_pointer (this); + } +} + +ImplementationRepository::ServerInformationIterator::~ServerInformationIterator (void) +{} + +void +ImplementationRepository::ServerInformationIterator::_tao_any_destructor (void *_tao_void_pointer) +{ + ServerInformationIterator *_tao_tmp_pointer = + static_cast<ServerInformationIterator *> (_tao_void_pointer); + CORBA::release (_tao_tmp_pointer); +} + +ImplementationRepository::ServerInformationIterator_ptr +ImplementationRepository::ServerInformationIterator::_narrow ( + CORBA::Object_ptr _tao_objref + ACE_ENV_ARG_DECL + ) +{ + return + TAO::Narrow_Utils<ServerInformationIterator>::narrow ( + _tao_objref, + "IDL:ImplementationRepository/ServerInformationIterator:1.0", + ImplementationRepository__TAO_ServerInformationIterator_Proxy_Broker_Factory_function_pointer + ACE_ENV_ARG_PARAMETER + ); +} + +ImplementationRepository::ServerInformationIterator_ptr +ImplementationRepository::ServerInformationIterator::_unchecked_narrow ( + CORBA::Object_ptr _tao_objref + ACE_ENV_ARG_DECL + ) +{ + return + TAO::Narrow_Utils<ServerInformationIterator>::unchecked_narrow ( + _tao_objref, + "IDL:ImplementationRepository/ServerInformationIterator:1.0", + ImplementationRepository__TAO_ServerInformationIterator_Proxy_Broker_Factory_function_pointer + ACE_ENV_ARG_PARAMETER + ); +} + +ImplementationRepository::ServerInformationIterator_ptr +ImplementationRepository::ServerInformationIterator::_duplicate (ServerInformationIterator_ptr obj) +{ + if (! CORBA::is_nil (obj)) + { + obj->_add_ref (); + } + + return obj; +} + +CORBA::Boolean +ImplementationRepository::ServerInformationIterator::_is_a ( + const char *value + ACE_ENV_ARG_DECL + ) +{ + if ( + !ACE_OS::strcmp ( + value, + "IDL:ImplementationRepository/ServerInformationIterator:1.0" + ) || + !ACE_OS::strcmp ( + value, + "IDL:omg.org/CORBA/Object:1.0" + ) + ) + { + return 1; // success using local knowledge + } + else + { + return this->ACE_NESTED_CLASS (CORBA, Object)::_is_a ( + value + ACE_ENV_ARG_PARAMETER + ); + } +} + +const char* ImplementationRepository::ServerInformationIterator::_interface_repository_id (void) const +{ + return "IDL:ImplementationRepository/ServerInformationIterator:1.0"; +} + +CORBA::Boolean +ImplementationRepository::ServerInformationIterator::marshal (TAO_OutputCDR &cdr) +{ + return (cdr << this); +} + +// TAO_IDL - Generated from +// be\be_visitor_interface/interface_cs.cpp:60 + +// Traits specializations for ImplementationRepository::Administration. + +ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION +ImplementationRepository::Administration_ptr +TAO::Objref_Traits<ImplementationRepository::Administration>::duplicate ( + ImplementationRepository::Administration_ptr p + ) +{ + return ImplementationRepository::Administration::_duplicate (p); +} + +ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION +void +TAO::Objref_Traits<ImplementationRepository::Administration>::release ( + ImplementationRepository::Administration_ptr p + ) +{ + CORBA::release (p); +} + +ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION +ImplementationRepository::Administration_ptr +TAO::Objref_Traits<ImplementationRepository::Administration>::nil (void) +{ + return ImplementationRepository::Administration::_nil (); +} + +ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION +CORBA::Boolean +TAO::Objref_Traits<ImplementationRepository::Administration>::marshal ( + ImplementationRepository::Administration_ptr p, + TAO_OutputCDR & cdr + ) +{ + return CORBA::Object::marshal (p, cdr); +} + +// Function pointer for collocation factory initialization. +TAO::Collocation_Proxy_Broker * +(*ImplementationRepository__TAO_Administration_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_cs.cpp:78 + +void ImplementationRepository::Administration::activate_server ( + const char * server + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound, + ::ImplementationRepository::CannotActivate + )) +{ + if (!this->is_evaluated ()) + { + ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this); + } + + if (this->the_TAO_Administration_Proxy_Broker_ == 0) + { + ImplementationRepository_Administration_setup_collocation (); + } + + TAO::Arg_Traits< void>::ret_val _tao_retval; + TAO::Arg_Traits< CORBA::Char *>::in_arg_val _tao_server (server); + + TAO::Argument *_the_tao_operation_signature [] = + { + &_tao_retval, + &_tao_server + }; + + static TAO::Exception_Data + _tao_ImplementationRepository_Administration_activate_server_exceptiondata [] = + { + { + "IDL:ImplementationRepository/NotFound:1.0", + ImplementationRepository::NotFound::_alloc, + ImplementationRepository::_tc_NotFound + }, + + { + "IDL:ImplementationRepository/CannotActivate:1.0", + ImplementationRepository::CannotActivate::_alloc, + ImplementationRepository::_tc_CannotActivate + } + }; + + TAO::Invocation_Adapter _tao_call ( + this, + _the_tao_operation_signature, + 2, + "activate_server", + 15, + this->the_TAO_Administration_Proxy_Broker_ + ); + + _tao_call.invoke ( + _tao_ImplementationRepository_Administration_activate_server_exceptiondata, + 2 + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_cs.cpp:78 + +void ImplementationRepository::Administration::register_server ( + const char * server, + const ::ImplementationRepository::StartupOptions & options + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::AlreadyRegistered, + ::ImplementationRepository::NotFound + )) +{ + if (!this->is_evaluated ()) + { + ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this); + } + + if (this->the_TAO_Administration_Proxy_Broker_ == 0) + { + ImplementationRepository_Administration_setup_collocation (); + } + + TAO::Arg_Traits< void>::ret_val _tao_retval; + TAO::Arg_Traits< CORBA::Char *>::in_arg_val _tao_server (server); + TAO::Arg_Traits< ImplementationRepository::StartupOptions>::in_arg_val _tao_options (options); + + TAO::Argument *_the_tao_operation_signature [] = + { + &_tao_retval, + &_tao_server, + &_tao_options + }; + + static TAO::Exception_Data + _tao_ImplementationRepository_Administration_register_server_exceptiondata [] = + { + { + "IDL:ImplementationRepository/AlreadyRegistered:1.0", + ImplementationRepository::AlreadyRegistered::_alloc, + ImplementationRepository::_tc_AlreadyRegistered + }, + + { + "IDL:ImplementationRepository/NotFound:1.0", + ImplementationRepository::NotFound::_alloc, + ImplementationRepository::_tc_NotFound + } + }; + + TAO::Invocation_Adapter _tao_call ( + this, + _the_tao_operation_signature, + 3, + "register_server", + 15, + this->the_TAO_Administration_Proxy_Broker_ + ); + + _tao_call.invoke ( + _tao_ImplementationRepository_Administration_register_server_exceptiondata, + 2 + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_cs.cpp:78 + +void ImplementationRepository::Administration::reregister_server ( + const char * server, + const ::ImplementationRepository::StartupOptions & options + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::AlreadyRegistered, + ::ImplementationRepository::NotFound + )) +{ + if (!this->is_evaluated ()) + { + ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this); + } + + if (this->the_TAO_Administration_Proxy_Broker_ == 0) + { + ImplementationRepository_Administration_setup_collocation (); + } + + TAO::Arg_Traits< void>::ret_val _tao_retval; + TAO::Arg_Traits< CORBA::Char *>::in_arg_val _tao_server (server); + TAO::Arg_Traits< ImplementationRepository::StartupOptions>::in_arg_val _tao_options (options); + + TAO::Argument *_the_tao_operation_signature [] = + { + &_tao_retval, + &_tao_server, + &_tao_options + }; + + static TAO::Exception_Data + _tao_ImplementationRepository_Administration_reregister_server_exceptiondata [] = + { + { + "IDL:ImplementationRepository/AlreadyRegistered:1.0", + ImplementationRepository::AlreadyRegistered::_alloc, + ImplementationRepository::_tc_AlreadyRegistered + }, + + { + "IDL:ImplementationRepository/NotFound:1.0", + ImplementationRepository::NotFound::_alloc, + ImplementationRepository::_tc_NotFound + } + }; + + TAO::Invocation_Adapter _tao_call ( + this, + _the_tao_operation_signature, + 3, + "reregister_server", + 17, + this->the_TAO_Administration_Proxy_Broker_ + ); + + _tao_call.invoke ( + _tao_ImplementationRepository_Administration_reregister_server_exceptiondata, + 2 + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_cs.cpp:78 + +void ImplementationRepository::Administration::remove_server ( + const char * server + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )) +{ + if (!this->is_evaluated ()) + { + ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this); + } + + if (this->the_TAO_Administration_Proxy_Broker_ == 0) + { + ImplementationRepository_Administration_setup_collocation (); + } + + TAO::Arg_Traits< void>::ret_val _tao_retval; + TAO::Arg_Traits< CORBA::Char *>::in_arg_val _tao_server (server); + + TAO::Argument *_the_tao_operation_signature [] = + { + &_tao_retval, + &_tao_server + }; + + static TAO::Exception_Data + _tao_ImplementationRepository_Administration_remove_server_exceptiondata [] = + { + { + "IDL:ImplementationRepository/NotFound:1.0", + ImplementationRepository::NotFound::_alloc, + ImplementationRepository::_tc_NotFound + } + }; + + TAO::Invocation_Adapter _tao_call ( + this, + _the_tao_operation_signature, + 2, + "remove_server", + 13, + this->the_TAO_Administration_Proxy_Broker_ + ); + + _tao_call.invoke ( + _tao_ImplementationRepository_Administration_remove_server_exceptiondata, + 1 + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_cs.cpp:78 + +void ImplementationRepository::Administration::shutdown_server ( + const char * server + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )) +{ + if (!this->is_evaluated ()) + { + ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this); + } + + if (this->the_TAO_Administration_Proxy_Broker_ == 0) + { + ImplementationRepository_Administration_setup_collocation (); + } + + TAO::Arg_Traits< void>::ret_val _tao_retval; + TAO::Arg_Traits< CORBA::Char *>::in_arg_val _tao_server (server); + + TAO::Argument *_the_tao_operation_signature [] = + { + &_tao_retval, + &_tao_server + }; + + static TAO::Exception_Data + _tao_ImplementationRepository_Administration_shutdown_server_exceptiondata [] = + { + { + "IDL:ImplementationRepository/NotFound:1.0", + ImplementationRepository::NotFound::_alloc, + ImplementationRepository::_tc_NotFound + } + }; + + TAO::Invocation_Adapter _tao_call ( + this, + _the_tao_operation_signature, + 2, + "shutdown_server", + 15, + this->the_TAO_Administration_Proxy_Broker_ + ); + + _tao_call.invoke ( + _tao_ImplementationRepository_Administration_shutdown_server_exceptiondata, + 1 + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_cs.cpp:78 + +void ImplementationRepository::Administration::server_is_running ( + const char * server, + const char * partial_ior, + ::ImplementationRepository::ServerObject_ptr server_object + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )) +{ + if (!this->is_evaluated ()) + { + ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this); + } + + if (this->the_TAO_Administration_Proxy_Broker_ == 0) + { + ImplementationRepository_Administration_setup_collocation (); + } + + TAO::Arg_Traits< void>::ret_val _tao_retval; + TAO::Arg_Traits< CORBA::Char *>::in_arg_val _tao_server (server); + TAO::Arg_Traits< CORBA::Char *>::in_arg_val _tao_partial_ior (partial_ior); + TAO::Arg_Traits< ImplementationRepository::ServerObject>::in_arg_val _tao_server_object (server_object); + + TAO::Argument *_the_tao_operation_signature [] = + { + &_tao_retval, + &_tao_server, + &_tao_partial_ior, + &_tao_server_object + }; + + static TAO::Exception_Data + _tao_ImplementationRepository_Administration_server_is_running_exceptiondata [] = + { + { + "IDL:ImplementationRepository/NotFound:1.0", + ImplementationRepository::NotFound::_alloc, + ImplementationRepository::_tc_NotFound + } + }; + + TAO::Invocation_Adapter _tao_call ( + this, + _the_tao_operation_signature, + 4, + "server_is_running", + 17, + this->the_TAO_Administration_Proxy_Broker_ + ); + + _tao_call.invoke ( + _tao_ImplementationRepository_Administration_server_is_running_exceptiondata, + 1 + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_cs.cpp:78 + +void ImplementationRepository::Administration::server_is_shutting_down ( + const char * server + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )) +{ + if (!this->is_evaluated ()) + { + ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this); + } + + if (this->the_TAO_Administration_Proxy_Broker_ == 0) + { + ImplementationRepository_Administration_setup_collocation (); + } + + TAO::Arg_Traits< void>::ret_val _tao_retval; + TAO::Arg_Traits< CORBA::Char *>::in_arg_val _tao_server (server); + + TAO::Argument *_the_tao_operation_signature [] = + { + &_tao_retval, + &_tao_server + }; + + static TAO::Exception_Data + _tao_ImplementationRepository_Administration_server_is_shutting_down_exceptiondata [] = + { + { + "IDL:ImplementationRepository/NotFound:1.0", + ImplementationRepository::NotFound::_alloc, + ImplementationRepository::_tc_NotFound + } + }; + + TAO::Invocation_Adapter _tao_call ( + this, + _the_tao_operation_signature, + 2, + "server_is_shutting_down", + 23, + this->the_TAO_Administration_Proxy_Broker_ + ); + + _tao_call.invoke ( + _tao_ImplementationRepository_Administration_server_is_shutting_down_exceptiondata, + 1 + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_cs.cpp:78 + +void ImplementationRepository::Administration::find ( + const char * server, + ::ImplementationRepository::ServerInformation_out info + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )) +{ + if (!this->is_evaluated ()) + { + ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this); + } + + if (this->the_TAO_Administration_Proxy_Broker_ == 0) + { + ImplementationRepository_Administration_setup_collocation (); + } + + TAO::Arg_Traits< void>::ret_val _tao_retval; + TAO::Arg_Traits< CORBA::Char *>::in_arg_val _tao_server (server); + TAO::Arg_Traits< ImplementationRepository::ServerInformation>::out_arg_val _tao_info (info); + + TAO::Argument *_the_tao_operation_signature [] = + { + &_tao_retval, + &_tao_server, + &_tao_info + }; + + static TAO::Exception_Data + _tao_ImplementationRepository_Administration_find_exceptiondata [] = + { + { + "IDL:ImplementationRepository/NotFound:1.0", + ImplementationRepository::NotFound::_alloc, + ImplementationRepository::_tc_NotFound + } + }; + + TAO::Invocation_Adapter _tao_call ( + this, + _the_tao_operation_signature, + 3, + "find", + 4, + this->the_TAO_Administration_Proxy_Broker_ + ); + + _tao_call.invoke ( + _tao_ImplementationRepository_Administration_find_exceptiondata, + 1 + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_cs.cpp:78 + +void ImplementationRepository::Administration::list ( + ::CORBA::ULong how_many, + ::ImplementationRepository::ServerInformationList_out server_list, + ::ImplementationRepository::ServerInformationIterator_out server_iterator + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + if (!this->is_evaluated ()) + { + ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this); + } + + if (this->the_TAO_Administration_Proxy_Broker_ == 0) + { + ImplementationRepository_Administration_setup_collocation (); + } + + TAO::Arg_Traits< void>::ret_val _tao_retval; + TAO::Arg_Traits< ::CORBA::ULong>::in_arg_val _tao_how_many (how_many); + TAO::Arg_Traits< ImplementationRepository::ServerInformationList>::out_arg_val _tao_server_list (server_list); + TAO::Arg_Traits< ImplementationRepository::ServerInformationIterator>::out_arg_val _tao_server_iterator (server_iterator); + + TAO::Argument *_the_tao_operation_signature [] = + { + &_tao_retval, + &_tao_how_many, + &_tao_server_list, + &_tao_server_iterator + }; + + TAO::Invocation_Adapter _tao_call ( + this, + _the_tao_operation_signature, + 4, + "list", + 4, + this->the_TAO_Administration_Proxy_Broker_ + ); + + _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER); + ACE_CHECK; +} + +ImplementationRepository::Administration::Administration (void) + : the_TAO_Administration_Proxy_Broker_ (0) +{ + this->ImplementationRepository_Administration_setup_collocation (); +} + +void +ImplementationRepository::Administration::ImplementationRepository_Administration_setup_collocation () +{ + if (::ImplementationRepository__TAO_Administration_Proxy_Broker_Factory_function_pointer) + { + this->the_TAO_Administration_Proxy_Broker_ = + ::ImplementationRepository__TAO_Administration_Proxy_Broker_Factory_function_pointer (this); + } +} + +ImplementationRepository::Administration::~Administration (void) +{} + +void +ImplementationRepository::Administration::_tao_any_destructor (void *_tao_void_pointer) +{ + Administration *_tao_tmp_pointer = + static_cast<Administration *> (_tao_void_pointer); + CORBA::release (_tao_tmp_pointer); +} + +ImplementationRepository::Administration_ptr +ImplementationRepository::Administration::_narrow ( + CORBA::Object_ptr _tao_objref + ACE_ENV_ARG_DECL + ) +{ + return + TAO::Narrow_Utils<Administration>::narrow ( + _tao_objref, + "IDL:ImplementationRepository/Administration:1.0", + ImplementationRepository__TAO_Administration_Proxy_Broker_Factory_function_pointer + ACE_ENV_ARG_PARAMETER + ); +} + +ImplementationRepository::Administration_ptr +ImplementationRepository::Administration::_unchecked_narrow ( + CORBA::Object_ptr _tao_objref + ACE_ENV_ARG_DECL + ) +{ + return + TAO::Narrow_Utils<Administration>::unchecked_narrow ( + _tao_objref, + "IDL:ImplementationRepository/Administration:1.0", + ImplementationRepository__TAO_Administration_Proxy_Broker_Factory_function_pointer + ACE_ENV_ARG_PARAMETER + ); +} + +ImplementationRepository::Administration_ptr +ImplementationRepository::Administration::_duplicate (Administration_ptr obj) +{ + if (! CORBA::is_nil (obj)) + { + obj->_add_ref (); + } + + return obj; +} + +CORBA::Boolean +ImplementationRepository::Administration::_is_a ( + const char *value + ACE_ENV_ARG_DECL + ) +{ + if ( + !ACE_OS::strcmp ( + value, + "IDL:ImplementationRepository/Administration:1.0" + ) || + !ACE_OS::strcmp ( + value, + "IDL:omg.org/CORBA/Object:1.0" + ) + ) + { + return 1; // success using local knowledge + } + else + { + return this->ACE_NESTED_CLASS (CORBA, Object)::_is_a ( + value + ACE_ENV_ARG_PARAMETER + ); + } +} + +const char* ImplementationRepository::Administration::_interface_repository_id (void) const +{ + return "IDL:ImplementationRepository/Administration:1.0"; +} + +CORBA::Boolean +ImplementationRepository::Administration::marshal (TAO_OutputCDR &cdr) +{ + return (cdr << this); +} + +// TAO_IDL - Generated from +// be\be_visitor_exception/cdr_op_cs.cpp:60 + +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const ImplementationRepository::AlreadyRegistered &_tao_aggregate + ) +{ + // Marshal the repository ID. + return (strm << _tao_aggregate._rep_id ()); +} + +CORBA::Boolean operator>> ( + TAO_InputCDR &, + ImplementationRepository::AlreadyRegistered& + ) +{ + return true; +} + +// TAO_IDL - Generated from +// be\be_visitor_exception/cdr_op_cs.cpp:60 + +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const ImplementationRepository::CannotActivate &_tao_aggregate + ) +{ + // First marshal the repository ID. + if (strm << _tao_aggregate._rep_id ()) + { + // Now marshal the members (if any). + return ( + (strm << _tao_aggregate.reason.in ()) + ); + } + else + { + return false; + } +} + +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + ImplementationRepository::CannotActivate &_tao_aggregate + ) +{ + // Demarshal the members. + return ( + (strm >> _tao_aggregate.reason.out ()) + ); +} + +// TAO_IDL - Generated from +// be\be_visitor_exception/cdr_op_cs.cpp:60 + +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const ImplementationRepository::NotFound &_tao_aggregate + ) +{ + // Marshal the repository ID. + return (strm << _tao_aggregate._rep_id ()); +} + +CORBA::Boolean operator>> ( + TAO_InputCDR &, + ImplementationRepository::NotFound& + ) +{ + return true; +} + +// TAO_IDL - Generated from +// be\be_visitor_structure/cdr_op_cs.cpp:61 + +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const ImplementationRepository::EnvironmentVariable &_tao_aggregate + ) +{ + return + (strm << _tao_aggregate.name.in ()) && + (strm << _tao_aggregate.value.in ()); +} + +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + ImplementationRepository::EnvironmentVariable &_tao_aggregate + ) +{ + return + (strm >> _tao_aggregate.name.out ()) && + (strm >> _tao_aggregate.value.out ()); +} + +// TAO_IDL - Generated from +// be\be_visitor_sequence/cdr_op_cs.cpp:96 + +#if !defined _TAO_CDR_OP_ImplementationRepository_EnvironmentList_CPP_ +#define _TAO_CDR_OP_ImplementationRepository_EnvironmentList_CPP_ + +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const ImplementationRepository::EnvironmentList &_tao_sequence + ) +{ + const CORBA::ULong _tao_seq_len = _tao_sequence.length (); + + if (strm << _tao_seq_len) + { + // Encode all elements. + CORBA::Boolean _tao_marshal_flag = true; + + for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i) + { + _tao_marshal_flag = (strm << _tao_sequence[i]); + } + + return _tao_marshal_flag; + } + + return false; +} + +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + ImplementationRepository::EnvironmentList &_tao_sequence + ) +{ + CORBA::ULong _tao_seq_len; + + if (strm >> _tao_seq_len) + { + // Add a check to the length of the sequence + // to make sure it does not exceed the length + // of the stream. (See bug 58.) + if (_tao_seq_len > strm.length ()) + { + return false; + } + + // Set the length of the sequence. + _tao_sequence.length (_tao_seq_len); + + // If length is 0 we return true. + if (0 >= _tao_seq_len) + { + return true; + } + + // Retrieve all the elements. + CORBA::Boolean _tao_marshal_flag = true; + + for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i) + { + _tao_marshal_flag = (strm >> _tao_sequence[i]); + } + + return _tao_marshal_flag; + + } + + return false; +} + +#endif /* _TAO_CDR_OP_ImplementationRepository_EnvironmentList_CPP_ */ + +// TAO_IDL - Generated from +// be\be_visitor_enum/cdr_op_cs.cpp:51 + +CORBA::Boolean operator<< (TAO_OutputCDR &strm, const ImplementationRepository::ActivationMode &_tao_enumval) +{ + CORBA::ULong _tao_temp = _tao_enumval; + return strm << _tao_temp; +} + +CORBA::Boolean operator>> (TAO_InputCDR &strm, ImplementationRepository::ActivationMode &_tao_enumval) +{ + CORBA::ULong _tao_temp = 0; + CORBA::Boolean _tao_result = strm >> _tao_temp; + + if (_tao_result == 1) + { + _tao_enumval = static_cast<ImplementationRepository::ActivationMode> (_tao_temp); + } + + return _tao_result; +} + +// TAO_IDL - Generated from +// be\be_visitor_structure/cdr_op_cs.cpp:61 + +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const ImplementationRepository::StartupOptions &_tao_aggregate + ) +{ + return + (strm << _tao_aggregate.command_line.in ()) && + (strm << _tao_aggregate.environment) && + (strm << _tao_aggregate.working_directory.in ()) && + (strm << _tao_aggregate.activation) && + (strm << _tao_aggregate.activator.in ()) && + (strm << _tao_aggregate.start_limit); +} + +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + ImplementationRepository::StartupOptions &_tao_aggregate + ) +{ + return + (strm >> _tao_aggregate.command_line.out ()) && + (strm >> _tao_aggregate.environment) && + (strm >> _tao_aggregate.working_directory.out ()) && + (strm >> _tao_aggregate.activation) && + (strm >> _tao_aggregate.activator.out ()) && + (strm >> _tao_aggregate.start_limit); +} + +// TAO_IDL - Generated from +// be\be_visitor_structure/cdr_op_cs.cpp:61 + +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const ImplementationRepository::ServerInformation &_tao_aggregate + ) +{ + return + (strm << _tao_aggregate.server.in ()) && + (strm << _tao_aggregate.startup) && + (strm << _tao_aggregate.partial_ior.in ()); +} + +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + ImplementationRepository::ServerInformation &_tao_aggregate + ) +{ + return + (strm >> _tao_aggregate.server.out ()) && + (strm >> _tao_aggregate.startup) && + (strm >> _tao_aggregate.partial_ior.out ()); +} + +// TAO_IDL - Generated from +// be\be_visitor_sequence/cdr_op_cs.cpp:96 + +#if !defined _TAO_CDR_OP_ImplementationRepository_ServerInformationList_CPP_ +#define _TAO_CDR_OP_ImplementationRepository_ServerInformationList_CPP_ + +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const ImplementationRepository::ServerInformationList &_tao_sequence + ) +{ + const CORBA::ULong _tao_seq_len = _tao_sequence.length (); + + if (strm << _tao_seq_len) + { + // Encode all elements. + CORBA::Boolean _tao_marshal_flag = true; + + for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i) + { + _tao_marshal_flag = (strm << _tao_sequence[i]); + } + + return _tao_marshal_flag; + } + + return false; +} + +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + ImplementationRepository::ServerInformationList &_tao_sequence + ) +{ + CORBA::ULong _tao_seq_len; + + if (strm >> _tao_seq_len) + { + // Add a check to the length of the sequence + // to make sure it does not exceed the length + // of the stream. (See bug 58.) + if (_tao_seq_len > strm.length ()) + { + return false; + } + + // Set the length of the sequence. + _tao_sequence.length (_tao_seq_len); + + // If length is 0 we return true. + if (0 >= _tao_seq_len) + { + return true; + } + + // Retrieve all the elements. + CORBA::Boolean _tao_marshal_flag = true; + + for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i) + { + _tao_marshal_flag = (strm >> _tao_sequence[i]); + } + + return _tao_marshal_flag; + + } + + return false; +} + +#endif /* _TAO_CDR_OP_ImplementationRepository_ServerInformationList_CPP_ */ + +// TAO_IDL - Generated from +// be\be_visitor_interface/cdr_op_cs.cpp:63 + +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const ImplementationRepository::ServerInformationIterator_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + ImplementationRepository::ServerInformationIterator_ptr &_tao_objref + ) +{ + CORBA::Object_var obj; + + if (!(strm >> obj.inout ())) + { + return false; + } + + typedef ::ImplementationRepository::ServerInformationIterator RHS_SCOPED_NAME; + + // Narrow to the right type. + _tao_objref = + TAO::Narrow_Utils<RHS_SCOPED_NAME>::unchecked_narrow ( + obj.in (), + ImplementationRepository__TAO_ServerInformationIterator_Proxy_Broker_Factory_function_pointer + ); + + return 1; +} + +// TAO_IDL - Generated from +// be\be_visitor_interface/cdr_op_cs.cpp:63 + +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const ImplementationRepository::Administration_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + ImplementationRepository::Administration_ptr &_tao_objref + ) +{ + CORBA::Object_var obj; + + if (!(strm >> obj.inout ())) + { + return false; + } + + typedef ::ImplementationRepository::Administration RHS_SCOPED_NAME; + + // Narrow to the right type. + _tao_objref = + TAO::Narrow_Utils<RHS_SCOPED_NAME>::unchecked_narrow ( + obj.in (), + ImplementationRepository__TAO_Administration_Proxy_Broker_Factory_function_pointer + ); + + return 1; +} + +// TAO_IDL - Generated from +// be\be_visitor_root/root.cpp:1629 + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVEROBJECT__ARG_TRAITS_TMPLINST_CS_) +#define _IMPLEMENTATIONREPOSITORY_SERVEROBJECT__ARG_TRAITS_TMPLINST_CS_ + + template class + TAO::Arg_Traits< + ImplementationRepository::ServerObject + >; + + template class + TAO::Object_Arg_Traits_T< + ImplementationRepository::ServerObject_ptr, + ImplementationRepository::ServerObject_var, + ImplementationRepository::ServerObject_out, + TAO::Objref_Traits<ImplementationRepository::ServerObject> + >; + +#endif /* end #if !defined */ + + template class + TAO_Var_Var_T< + ImplementationRepository::EnvironmentVariable + >; + + template class + TAO_Var_Base_T< + ImplementationRepository::EnvironmentVariable + >; + + template class + TAO_Out_T< + ImplementationRepository::EnvironmentVariable, + ImplementationRepository::EnvironmentVariable_var + >; + + template class + TAO_VarSeq_Var_T< + ImplementationRepository::EnvironmentList, + ImplementationRepository::EnvironmentVariable + >; + + template class + TAO_Seq_Var_Base_T< + ImplementationRepository::EnvironmentList, + ImplementationRepository::EnvironmentVariable + >; + + template class + TAO_Seq_Out_T< + ImplementationRepository::EnvironmentList, + ImplementationRepository::EnvironmentList_var, + ImplementationRepository::EnvironmentVariable + >; + +#if !defined (_IMPLEMENTATIONREPOSITORY_ENVIRONMENTVARIABLE__EXPLICIT_CS_) +#define _IMPLEMENTATIONREPOSITORY_ENVIRONMENTVARIABLE__EXPLICIT_CS_ + + template class + TAO_Unbounded_Sequence< + ImplementationRepository::EnvironmentVariable + >; + +#endif /* end #if !defined */ + +#if !defined (_IMPLEMENTATIONREPOSITORY_STARTUPOPTIONS__ARG_TRAITS_TMPLINST_CS_) +#define _IMPLEMENTATIONREPOSITORY_STARTUPOPTIONS__ARG_TRAITS_TMPLINST_CS_ + + template class TAO::Arg_Traits<ImplementationRepository::StartupOptions>; + + template class + TAO::Var_Size_Arg_Traits_T< + ImplementationRepository::StartupOptions, + ImplementationRepository::StartupOptions_var, + ImplementationRepository::StartupOptions_out + >; + +#endif /* end #if !defined */ + + template class + TAO_Var_Var_T< + ImplementationRepository::StartupOptions + >; + + template class + TAO_Var_Base_T< + ImplementationRepository::StartupOptions + >; + + template class + TAO_Out_T< + ImplementationRepository::StartupOptions, + ImplementationRepository::StartupOptions_var + >; + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATION__ARG_TRAITS_TMPLINST_CS_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATION__ARG_TRAITS_TMPLINST_CS_ + + template class TAO::Arg_Traits<ImplementationRepository::ServerInformation>; + + template class + TAO::Var_Size_Arg_Traits_T< + ImplementationRepository::ServerInformation, + ImplementationRepository::ServerInformation_var, + ImplementationRepository::ServerInformation_out + >; + +#endif /* end #if !defined */ + + template class + TAO_Var_Var_T< + ImplementationRepository::ServerInformation + >; + + template class + TAO_Var_Base_T< + ImplementationRepository::ServerInformation + >; + + template class + TAO_Out_T< + ImplementationRepository::ServerInformation, + ImplementationRepository::ServerInformation_var + >; + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST__ARG_TRAITS_TMPLINST_CS_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST__ARG_TRAITS_TMPLINST_CS_ + + template class TAO::Arg_Traits<ImplementationRepository::ServerInformationList>; + + template class + TAO::Var_Size_Arg_Traits_T< + ImplementationRepository::ServerInformationList, + ImplementationRepository::ServerInformationList_var, + ImplementationRepository::ServerInformationList_out + >; + +#endif /* end #if !defined */ + + template class + TAO_VarSeq_Var_T< + ImplementationRepository::ServerInformationList, + ImplementationRepository::ServerInformation + >; + + template class + TAO_Seq_Var_Base_T< + ImplementationRepository::ServerInformationList, + ImplementationRepository::ServerInformation + >; + + template class + TAO_Seq_Out_T< + ImplementationRepository::ServerInformationList, + ImplementationRepository::ServerInformationList_var, + ImplementationRepository::ServerInformation + >; + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATION__EXPLICIT_CS_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATION__EXPLICIT_CS_ + + template class + TAO_Unbounded_Sequence< + ImplementationRepository::ServerInformation + >; + +#endif /* end #if !defined */ + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR__ARG_TRAITS_TMPLINST_CS_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR__ARG_TRAITS_TMPLINST_CS_ + + template class + TAO::Arg_Traits< + ImplementationRepository::ServerInformationIterator + >; + + template class + TAO::Object_Arg_Traits_T< + ImplementationRepository::ServerInformationIterator_ptr, + ImplementationRepository::ServerInformationIterator_var, + ImplementationRepository::ServerInformationIterator_out, + TAO::Objref_Traits<ImplementationRepository::ServerInformationIterator> + >; + +#endif /* end #if !defined */ + + template class + TAO::Out_Var_Size_Argument_T< + ImplementationRepository::ServerInformationList, + ImplementationRepository::ServerInformationList_out + >; + + template class + TAO::Objref_Traits< + ImplementationRepository::ServerInformationIterator + >; + + template class + TAO_Objref_Var_T< + ImplementationRepository::ServerInformationIterator + >; + + template class + TAO_Objref_Out_T< + ImplementationRepository::ServerInformationIterator + >; + + template class + TAO::Narrow_Utils< + ImplementationRepository::ServerInformationIterator + >; + + template class + TAO::In_Var_Size_Argument_T< + ImplementationRepository::StartupOptions + >; + + template class + TAO::In_Object_Argument_T< + ImplementationRepository::ServerObject_ptr + >; + + template class + TAO::Out_Var_Size_Argument_T< + ImplementationRepository::ServerInformation, + ImplementationRepository::ServerInformation_out + >; + + template class + TAO::Out_Object_Argument_T< + ImplementationRepository::ServerInformationIterator_ptr, + ImplementationRepository::ServerInformationIterator_out + >; + + template class + TAO::Objref_Traits< + ImplementationRepository::Administration + >; + + template class + TAO_Objref_Var_T< + ImplementationRepository::Administration + >; + + template class + TAO_Objref_Out_T< + ImplementationRepository::Administration + >; + + template class + TAO::Narrow_Utils< + ImplementationRepository::Administration + >; + +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVEROBJECT__ARG_TRAITS_TMPLINST_CS_) +#define _IMPLEMENTATIONREPOSITORY_SERVEROBJECT__ARG_TRAITS_TMPLINST_CS_ + +# pragma instantiate \ + TAO::Arg_Traits< \ + ImplementationRepository::ServerObject \ + > + +# pragma instantiate \ + TAO::Object_Arg_Traits_T< \ + ImplementationRepository::ServerObject_ptr, \ + ImplementationRepository::ServerObject_var, \ + ImplementationRepository::ServerObject_out, \ + TAO::Objref_Traits<ImplementationRepository::ServerObject> \ + > + +#endif /* end #if !defined */ + +# pragma instantiate \ + TAO_Var_Var_T< \ + ImplementationRepository::EnvironmentVariable \ + > + +# pragma instantiate \ + TAO_Var_Base_T< \ + ImplementationRepository::EnvironmentVariable \ + > + +# pragma instantiate \ + TAO_Out_T< \ + ImplementationRepository::EnvironmentVariable, \ + ImplementationRepository::EnvironmentVariable_var \ + > + +# pragma instantiate \ + TAO_VarSeq_Var_T< \ + ImplementationRepository::EnvironmentList, \ + ImplementationRepository::EnvironmentVariable \ + > + +# pragma instantiate \ + TAO_Seq_Var_Base_T< \ + ImplementationRepository::EnvironmentList, \ + ImplementationRepository::EnvironmentVariable \ + > + +# pragma instantiate \ + TAO_Seq_Out_T< \ + ImplementationRepository::EnvironmentList, \ + ImplementationRepository::EnvironmentList_var, \ + ImplementationRepository::EnvironmentVariable \ + > + +#if !defined (_IMPLEMENTATIONREPOSITORY_ENVIRONMENTVARIABLE__EXPLICIT_CS_) +#define _IMPLEMENTATIONREPOSITORY_ENVIRONMENTVARIABLE__EXPLICIT_CS_ + +# pragma instantiate \ + TAO_Unbounded_Sequence< \ + ImplementationRepository::EnvironmentVariable \ + > + +#endif /* end #if !defined */ + +#if !defined (_IMPLEMENTATIONREPOSITORY_STARTUPOPTIONS__ARG_TRAITS_TMPLINST_CS_) +#define _IMPLEMENTATIONREPOSITORY_STARTUPOPTIONS__ARG_TRAITS_TMPLINST_CS_ + +# pragma instantiate TAO::Arg_Traits<ImplementationRepository::StartupOptions> + +# pragma instantiate \ + TAO::Var_Size_Arg_Traits_T< \ + ImplementationRepository::StartupOptions, \ + ImplementationRepository::StartupOptions_var, \ + ImplementationRepository::StartupOptions_out \ + > + +#endif /* end #if !defined */ + +# pragma instantiate \ + TAO_Var_Var_T< \ + ImplementationRepository::StartupOptions \ + > + +# pragma instantiate \ + TAO_Var_Base_T< \ + ImplementationRepository::StartupOptions \ + > + +# pragma instantiate \ + TAO_Out_T< \ + ImplementationRepository::StartupOptions, \ + ImplementationRepository::StartupOptions_var \ + > + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATION__ARG_TRAITS_TMPLINST_CS_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATION__ARG_TRAITS_TMPLINST_CS_ + +# pragma instantiate TAO::Arg_Traits<ImplementationRepository::ServerInformation> + +# pragma instantiate \ + TAO::Var_Size_Arg_Traits_T< \ + ImplementationRepository::ServerInformation, \ + ImplementationRepository::ServerInformation_var, \ + ImplementationRepository::ServerInformation_out \ + > + +#endif /* end #if !defined */ + +# pragma instantiate \ + TAO_Var_Var_T< \ + ImplementationRepository::ServerInformation \ + > + +# pragma instantiate \ + TAO_Var_Base_T< \ + ImplementationRepository::ServerInformation \ + > + +# pragma instantiate \ + TAO_Out_T< \ + ImplementationRepository::ServerInformation, \ + ImplementationRepository::ServerInformation_var \ + > + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST__ARG_TRAITS_TMPLINST_CS_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST__ARG_TRAITS_TMPLINST_CS_ + +# pragma instantiate TAO::Arg_Traits<ImplementationRepository::ServerInformationList> + +# pragma instantiate \ + TAO::Var_Size_Arg_Traits_T< \ + ImplementationRepository::ServerInformationList, \ + ImplementationRepository::ServerInformationList_var, \ + ImplementationRepository::ServerInformationList_out \ + > + +#endif /* end #if !defined */ + +# pragma instantiate \ + TAO_VarSeq_Var_T< \ + ImplementationRepository::ServerInformationList, \ + ImplementationRepository::ServerInformation \ + > + +# pragma instantiate \ + TAO_Seq_Var_Base_T< \ + ImplementationRepository::ServerInformationList, \ + ImplementationRepository::ServerInformation \ + > + +# pragma instantiate \ + TAO_Seq_Out_T< \ + ImplementationRepository::ServerInformationList, \ + ImplementationRepository::ServerInformationList_var, \ + ImplementationRepository::ServerInformation \ + > + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATION__EXPLICIT_CS_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATION__EXPLICIT_CS_ + +# pragma instantiate \ + TAO_Unbounded_Sequence< \ + ImplementationRepository::ServerInformation \ + > + +#endif /* end #if !defined */ + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR__ARG_TRAITS_TMPLINST_CS_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR__ARG_TRAITS_TMPLINST_CS_ + +# pragma instantiate \ + TAO::Arg_Traits< \ + ImplementationRepository::ServerInformationIterator \ + > + +# pragma instantiate \ + TAO::Object_Arg_Traits_T< \ + ImplementationRepository::ServerInformationIterator_ptr, \ + ImplementationRepository::ServerInformationIterator_var, \ + ImplementationRepository::ServerInformationIterator_out, \ + TAO::Objref_Traits<ImplementationRepository::ServerInformationIterator> \ + > + +#endif /* end #if !defined */ + +# pragma instantiate \ + TAO::Out_Var_Size_Argument_T< \ + ImplementationRepository::ServerInformationList, \ + ImplementationRepository::ServerInformationList_out \ + > + +# pragma instantiate \ + TAO::Objref_Traits< \ + ImplementationRepository::ServerInformationIterator \ + > + +# pragma instantiate \ + TAO_Objref_Var_T< \ + ImplementationRepository::ServerInformationIterator + > + +# pragma instantiate \ + TAO_Objref_Out_T< \ + ImplementationRepository::ServerInformationIterator + > + +# pragma instantiate \ + TAO::Narrow_Utils< \ + ImplementationRepository::ServerInformationIterator \ + > + +# pragma instantiate \ + TAO::In_Var_Size_Argument_T< \ + ImplementationRepository::StartupOptions \ + > + +# pragma instantiate \ + TAO::In_Object_Argument_T< \ + ImplementationRepository::ServerObject_ptr \ + > + +# pragma instantiate \ + TAO::Out_Var_Size_Argument_T< \ + ImplementationRepository::ServerInformation, \ + ImplementationRepository::ServerInformation_out \ + > + +# pragma instantiate \ + TAO::Out_Object_Argument_T< \ + ImplementationRepository::ServerInformationIterator_ptr, \ + ImplementationRepository::ServerInformationIterator_out \ + > + +# pragma instantiate \ + TAO::Objref_Traits< \ + ImplementationRepository::Administration \ + > + +# pragma instantiate \ + TAO_Objref_Var_T< \ + ImplementationRepository::Administration + > + +# pragma instantiate \ + TAO_Objref_Out_T< \ + ImplementationRepository::Administration + > + +# pragma instantiate \ + TAO::Narrow_Utils< \ + ImplementationRepository::Administration \ + > + +#endif /* !ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ diff --git a/TAO/tao/ImR_Client/ImplRepoC.h b/TAO/tao/ImR_Client/ImplRepoC.h new file mode 100644 index 00000000000..13f9d7c4ab5 --- /dev/null +++ b/TAO/tao/ImR_Client/ImplRepoC.h @@ -0,0 +1,1104 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// and +// Institute for Software Integrated Systems +// Vanderbilt University +// Nashville, TN +// USA +// http://www.isis.vanderbilt.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +// TAO_IDL - Generated from +// be\be_codegen.cpp:153 + +#ifndef _TAO_IDL_ORIG_IMPLREPOC_H_ +#define _TAO_IDL_ORIG_IMPLREPOC_H_ + +#include /**/ "ace/pre.h" + + +#include "ace/config-all.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "imr_client_export.h" +#include "tao/ORB.h" +#include "tao/SystemException.h" +#include "tao/Environment.h" +#include "tao/Object.h" +#include "tao/Sequence_T.h" +#include "tao/Objref_VarOut_T.h" +#include "tao/Seq_Var_T.h" +#include "tao/Seq_Out_T.h" +#include "tao/VarOut_T.h" + +#include "tao/ImR_Client/ServerObjectC.h" + +#if defined (TAO_EXPORT_MACRO) +#undef TAO_EXPORT_MACRO +#endif +#define TAO_EXPORT_MACRO TAO_IMR_Client_Export + +#if defined (TAO_EXPORT_NESTED_CLASSES) +# if defined (TAO_EXPORT_NESTED_MACRO) +# undef TAO_EXPORT_NESTED_MACRO +# endif /* defined (TAO_EXPORT_NESTED_MACRO) */ +# define TAO_EXPORT_NESTED_MACRO TAO_IMR_Client_Export +#endif /* TAO_EXPORT_NESTED_CLASSES */ + +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option push -w-rvl -w-rch -w-ccc -w-inl +#endif /* __BORLANDC__ */ + +// TAO_IDL - Generated from +// be\be_visitor_root/root_ch.cpp:62 + +namespace TAO +{ + class Collocation_Proxy_Broker; + + template<typename T> class Narrow_Utils; + template<typename T> class AbstractBase_Narrow_Utils; +} + +// TAO_IDL - Generated from +// be\be_visitor_module/module_ch.cpp:48 + +namespace ImplementationRepository +{ + + // TAO_IDL - Generated from + // be\be_visitor_exception/exception_ch.cpp:51 + +#if !defined (_IMPLEMENTATIONREPOSITORY_ALREADYREGISTERED_CH_) +#define _IMPLEMENTATIONREPOSITORY_ALREADYREGISTERED_CH_ + + class TAO_IMR_Client_Export AlreadyRegistered : public CORBA::UserException + { + public: + + AlreadyRegistered (void); + AlreadyRegistered (const AlreadyRegistered &); + ~AlreadyRegistered (void); + + AlreadyRegistered &operator= (const AlreadyRegistered &); + + static void _tao_any_destructor (void *); + + static AlreadyRegistered *_downcast (CORBA::Exception *); + static const AlreadyRegistered *_downcast (CORBA::Exception const *); + + static CORBA::Exception *_alloc (void); + + virtual CORBA::Exception *_tao_duplicate (void) const; + + virtual void _raise (void) const; + + virtual void _tao_encode ( + TAO_OutputCDR & + ACE_ENV_ARG_DECL + ) const; + + virtual void _tao_decode ( + TAO_InputCDR & + ACE_ENV_ARG_DECL + ); + + // TAO_IDL - Generated from + // be\be_visitor_exception/exception_ch.cpp:127 + + virtual CORBA::TypeCode_ptr _type (void) const; + }; + + // TAO_IDL - Generated from + // be\be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_AlreadyRegistered; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be\be_visitor_exception/exception_ch.cpp:51 + +#if !defined (_IMPLEMENTATIONREPOSITORY_CANNOTACTIVATE_CH_) +#define _IMPLEMENTATIONREPOSITORY_CANNOTACTIVATE_CH_ + + class TAO_IMR_Client_Export CannotActivate : public CORBA::UserException + { + public: + + TAO_String_Manager reason; + CannotActivate (void); + CannotActivate (const CannotActivate &); + ~CannotActivate (void); + + CannotActivate &operator= (const CannotActivate &); + + static void _tao_any_destructor (void *); + + static CannotActivate *_downcast (CORBA::Exception *); + static const CannotActivate *_downcast (CORBA::Exception const *); + + static CORBA::Exception *_alloc (void); + + virtual CORBA::Exception *_tao_duplicate (void) const; + + virtual void _raise (void) const; + + virtual void _tao_encode ( + TAO_OutputCDR & + ACE_ENV_ARG_DECL + ) const; + + virtual void _tao_decode ( + TAO_InputCDR & + ACE_ENV_ARG_DECL + ); + + // TAO_IDL - Generated from + // be\be_visitor_exception/exception_ctor.cpp:66 + + CannotActivate ( + const char * _tao_reason + ); + + // TAO_IDL - Generated from + // be\be_visitor_exception/exception_ch.cpp:127 + + virtual CORBA::TypeCode_ptr _type (void) const; + }; + + // TAO_IDL - Generated from + // be\be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_CannotActivate; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be\be_visitor_exception/exception_ch.cpp:51 + +#if !defined (_IMPLEMENTATIONREPOSITORY_NOTFOUND_CH_) +#define _IMPLEMENTATIONREPOSITORY_NOTFOUND_CH_ + + class TAO_IMR_Client_Export NotFound : public CORBA::UserException + { + public: + + NotFound (void); + NotFound (const NotFound &); + ~NotFound (void); + + NotFound &operator= (const NotFound &); + + static void _tao_any_destructor (void *); + + static NotFound *_downcast (CORBA::Exception *); + static const NotFound *_downcast (CORBA::Exception const *); + + static CORBA::Exception *_alloc (void); + + virtual CORBA::Exception *_tao_duplicate (void) const; + + virtual void _raise (void) const; + + virtual void _tao_encode ( + TAO_OutputCDR & + ACE_ENV_ARG_DECL + ) const; + + virtual void _tao_decode ( + TAO_InputCDR & + ACE_ENV_ARG_DECL + ); + + // TAO_IDL - Generated from + // be\be_visitor_exception/exception_ch.cpp:127 + + virtual CORBA::TypeCode_ptr _type (void) const; + }; + + // TAO_IDL - Generated from + // be\be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_NotFound; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be\be_type.cpp:258 + + struct EnvironmentVariable; + + typedef + TAO_Var_Var_T< + EnvironmentVariable + > + EnvironmentVariable_var; + + typedef + TAO_Out_T< + EnvironmentVariable, + EnvironmentVariable_var + > + EnvironmentVariable_out; + + // TAO_IDL - Generated from + // be\be_visitor_structure/structure_ch.cpp:52 + + struct TAO_IMR_Client_Export EnvironmentVariable + { + typedef EnvironmentVariable_var _var_type; + + static void _tao_any_destructor (void *); + TAO_String_Manager name; + TAO_String_Manager value; + }; + + // TAO_IDL - Generated from + // be\be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_EnvironmentVariable; + + // TAO_IDL - Generated from + // be\be_visitor_sequence/sequence_ch.cpp:101 + +#if !defined (_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CH_) +#define _IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CH_ + + class EnvironmentList; + + typedef + TAO_VarSeq_Var_T< + EnvironmentList, + EnvironmentVariable + > + EnvironmentList_var; + + typedef + TAO_Seq_Out_T< + EnvironmentList, + EnvironmentList_var, + EnvironmentVariable + > + EnvironmentList_out; + + class TAO_IMR_Client_Export EnvironmentList + : public + TAO_Unbounded_Sequence< + EnvironmentVariable + > + { + public: + EnvironmentList (void); + EnvironmentList (CORBA::ULong max); + EnvironmentList ( + CORBA::ULong max, + CORBA::ULong length, + EnvironmentVariable* buffer, + CORBA::Boolean release = 0 + ); + EnvironmentList (const EnvironmentList &); + ~EnvironmentList (void); + + static void _tao_any_destructor (void *); + + typedef EnvironmentList_var _var_type; + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be\be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_EnvironmentList; + + // TAO_IDL - Generated from + // be\be_visitor_enum/enum_ch.cpp:57 + + enum ActivationMode + { + NORMAL, + MANUAL, + PER_CLIENT, + AUTO_START + }; + + typedef ActivationMode &ActivationMode_out; + + // TAO_IDL - Generated from + // be\be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_ActivationMode; + + // TAO_IDL - Generated from + // be\be_type.cpp:258 + + struct StartupOptions; + + typedef + TAO_Var_Var_T< + StartupOptions + > + StartupOptions_var; + + typedef + TAO_Out_T< + StartupOptions, + StartupOptions_var + > + StartupOptions_out; + + // TAO_IDL - Generated from + // be\be_visitor_structure/structure_ch.cpp:52 + + struct TAO_IMR_Client_Export StartupOptions + { + typedef StartupOptions_var _var_type; + + static void _tao_any_destructor (void *); + TAO_String_Manager command_line; + ImplementationRepository::EnvironmentList environment; + TAO_String_Manager working_directory; + ImplementationRepository::ActivationMode activation; + TAO_String_Manager activator; + CORBA::Long start_limit; + }; + + // TAO_IDL - Generated from + // be\be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_StartupOptions; + + // TAO_IDL - Generated from + // be\be_type.cpp:258 + + struct ServerInformation; + + typedef + TAO_Var_Var_T< + ServerInformation + > + ServerInformation_var; + + typedef + TAO_Out_T< + ServerInformation, + ServerInformation_var + > + ServerInformation_out; + + // TAO_IDL - Generated from + // be\be_visitor_structure/structure_ch.cpp:52 + + struct TAO_IMR_Client_Export ServerInformation + { + typedef ServerInformation_var _var_type; + + static void _tao_any_destructor (void *); + TAO_String_Manager server; + ImplementationRepository::StartupOptions startup; + TAO_String_Manager partial_ior; + }; + + // TAO_IDL - Generated from + // be\be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_ServerInformation; + + // TAO_IDL - Generated from + // be\be_visitor_sequence/sequence_ch.cpp:101 + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CH_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CH_ + + class ServerInformationList; + + typedef + TAO_VarSeq_Var_T< + ServerInformationList, + ServerInformation + > + ServerInformationList_var; + + typedef + TAO_Seq_Out_T< + ServerInformationList, + ServerInformationList_var, + ServerInformation + > + ServerInformationList_out; + + class TAO_IMR_Client_Export ServerInformationList + : public + TAO_Unbounded_Sequence< + ServerInformation + > + { + public: + ServerInformationList (void); + ServerInformationList (CORBA::ULong max); + ServerInformationList ( + CORBA::ULong max, + CORBA::ULong length, + ServerInformation* buffer, + CORBA::Boolean release = 0 + ); + ServerInformationList (const ServerInformationList &); + ~ServerInformationList (void); + + static void _tao_any_destructor (void *); + + typedef ServerInformationList_var _var_type; + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be\be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_ServerInformationList; + + // TAO_IDL - Generated from + // be\be_interface.cpp:598 + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR__VAR_OUT_CH_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR__VAR_OUT_CH_ + + class ServerInformationIterator; + typedef ServerInformationIterator *ServerInformationIterator_ptr; + + typedef + TAO_Objref_Var_T< + ServerInformationIterator + > + ServerInformationIterator_var; + + typedef + TAO_Objref_Out_T< + ServerInformationIterator + > + ServerInformationIterator_out; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be\be_visitor_interface/interface_ch.cpp:54 + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR_CH_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR_CH_ + + class TAO_IMR_Client_Export ServerInformationIterator + : public virtual CORBA::Object + { + public: + friend class TAO::Narrow_Utils<ServerInformationIterator>; + typedef ServerInformationIterator_ptr _ptr_type; + typedef ServerInformationIterator_var _var_type; + + // The static operations. + static ServerInformationIterator_ptr _duplicate (ServerInformationIterator_ptr obj); + + static ServerInformationIterator_ptr _narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static ServerInformationIterator_ptr _unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static ServerInformationIterator_ptr _nil (void) + { + return static_cast<ServerInformationIterator_ptr> (0); + } + + static void _tao_any_destructor (void *); + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_ch.cpp:46 + + virtual CORBA::Boolean next_n ( + ::CORBA::ULong how_many, + ::ImplementationRepository::ServerInformationList_out servers + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_ch.cpp:46 + + virtual void destroy ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + // TAO_IDL - Generated from + // be\be_visitor_interface/interface_ch.cpp:208 + + virtual CORBA::Boolean _is_a ( + const char *type_id + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + virtual const char* _interface_repository_id (void) const; + virtual CORBA::Boolean marshal (TAO_OutputCDR &cdr); + private: + TAO::Collocation_Proxy_Broker *the_TAO_ServerInformationIterator_Proxy_Broker_; + + protected: + // Concrete interface only. + ServerInformationIterator (void); + + // These methods travese the inheritance tree and set the + // parents piece of the given class in the right mode. + virtual void ImplementationRepository_ServerInformationIterator_setup_collocation (void); + + // Concrete non-local interface only. + ServerInformationIterator ( + IOP::IOR *ior, + TAO_ORB_Core *orb_core = 0 + ); + + // Non-local interface only. + ServerInformationIterator ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0, + TAO_ORB_Core *orb_core = 0 + ); + + virtual ~ServerInformationIterator (void); + + private: + // Private and unimplemented for concrete interfaces. + ServerInformationIterator (const ServerInformationIterator &); + + void operator= (const ServerInformationIterator &); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be\be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_ServerInformationIterator; + + // TAO_IDL - Generated from + // be\be_interface.cpp:598 + +#if !defined (_IMPLEMENTATIONREPOSITORY_ADMINISTRATION__VAR_OUT_CH_) +#define _IMPLEMENTATIONREPOSITORY_ADMINISTRATION__VAR_OUT_CH_ + + class Administration; + typedef Administration *Administration_ptr; + + typedef + TAO_Objref_Var_T< + Administration + > + Administration_var; + + typedef + TAO_Objref_Out_T< + Administration + > + Administration_out; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be\be_visitor_interface/interface_ch.cpp:54 + +#if !defined (_IMPLEMENTATIONREPOSITORY_ADMINISTRATION_CH_) +#define _IMPLEMENTATIONREPOSITORY_ADMINISTRATION_CH_ + + class TAO_IMR_Client_Export Administration + : public virtual CORBA::Object + { + public: + friend class TAO::Narrow_Utils<Administration>; + typedef Administration_ptr _ptr_type; + typedef Administration_var _var_type; + + // The static operations. + static Administration_ptr _duplicate (Administration_ptr obj); + + static Administration_ptr _narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static Administration_ptr _unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static Administration_ptr _nil (void) + { + return static_cast<Administration_ptr> (0); + } + + static void _tao_any_destructor (void *); + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_ch.cpp:46 + + virtual void activate_server ( + const char * server + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound, + ::ImplementationRepository::CannotActivate + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_ch.cpp:46 + + virtual void register_server ( + const char * server, + const ::ImplementationRepository::StartupOptions & options + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::AlreadyRegistered, + ::ImplementationRepository::NotFound + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_ch.cpp:46 + + virtual void reregister_server ( + const char * server, + const ::ImplementationRepository::StartupOptions & options + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::AlreadyRegistered, + ::ImplementationRepository::NotFound + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_ch.cpp:46 + + virtual void remove_server ( + const char * server + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_ch.cpp:46 + + virtual void shutdown_server ( + const char * server + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_ch.cpp:46 + + virtual void server_is_running ( + const char * server, + const char * partial_ior, + ::ImplementationRepository::ServerObject_ptr server_object + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_ch.cpp:46 + + virtual void server_is_shutting_down ( + const char * server + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_ch.cpp:46 + + virtual void find ( + const char * server, + ::ImplementationRepository::ServerInformation_out info + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_ch.cpp:46 + + virtual void list ( + ::CORBA::ULong how_many, + ::ImplementationRepository::ServerInformationList_out server_list, + ::ImplementationRepository::ServerInformationIterator_out server_iterator + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + // TAO_IDL - Generated from + // be\be_visitor_interface/interface_ch.cpp:208 + + virtual CORBA::Boolean _is_a ( + const char *type_id + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + virtual const char* _interface_repository_id (void) const; + virtual CORBA::Boolean marshal (TAO_OutputCDR &cdr); + private: + TAO::Collocation_Proxy_Broker *the_TAO_Administration_Proxy_Broker_; + + protected: + // Concrete interface only. + Administration (void); + + // These methods travese the inheritance tree and set the + // parents piece of the given class in the right mode. + virtual void ImplementationRepository_Administration_setup_collocation (void); + + // Concrete non-local interface only. + Administration ( + IOP::IOR *ior, + TAO_ORB_Core *orb_core = 0 + ); + + // Non-local interface only. + Administration ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0, + TAO_ORB_Core *orb_core = 0 + ); + + virtual ~Administration (void); + + private: + // Private and unimplemented for concrete interfaces. + Administration (const Administration &); + + void operator= (const Administration &); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be\be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_Administration; + +// TAO_IDL - Generated from +// be\be_visitor_module/module_ch.cpp:66 + +} // module ImplementationRepository + +// Proxy Broker Factory function pointer declarations. + +// TAO_IDL - Generated from +// be\be_visitor_root/root.cpp:120 + +extern TAO_IMR_Client_Export +TAO::Collocation_Proxy_Broker * +(*ImplementationRepository__TAO_ServerInformationIterator_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); + +extern TAO_IMR_Client_Export +TAO::Collocation_Proxy_Broker * +(*ImplementationRepository__TAO_Administration_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); + +// TAO_IDL - Generated from +// be\be_visitor_traits.cpp:59 + +// Traits specializations. +namespace TAO +{ + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR__TRAITS_CH_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR__TRAITS_CH_ + + ACE_TEMPLATE_SPECIALIZATION + struct TAO_IMR_Client_Export Objref_Traits< ::ImplementationRepository::ServerInformationIterator> + { + static ::ImplementationRepository::ServerInformationIterator_ptr duplicate ( + ::ImplementationRepository::ServerInformationIterator_ptr + ); + static void release ( + ::ImplementationRepository::ServerInformationIterator_ptr + ); + static ::ImplementationRepository::ServerInformationIterator_ptr nil (void); + static CORBA::Boolean marshal ( + ::ImplementationRepository::ServerInformationIterator_ptr p, + TAO_OutputCDR & cdr + ); + }; + +#endif /* end #if !defined */ + +#if !defined (_IMPLEMENTATIONREPOSITORY_ADMINISTRATION__TRAITS_CH_) +#define _IMPLEMENTATIONREPOSITORY_ADMINISTRATION__TRAITS_CH_ + + ACE_TEMPLATE_SPECIALIZATION + struct TAO_IMR_Client_Export Objref_Traits< ::ImplementationRepository::Administration> + { + static ::ImplementationRepository::Administration_ptr duplicate ( + ::ImplementationRepository::Administration_ptr + ); + static void release ( + ::ImplementationRepository::Administration_ptr + ); + static ::ImplementationRepository::Administration_ptr nil (void); + static CORBA::Boolean marshal ( + ::ImplementationRepository::Administration_ptr p, + TAO_OutputCDR & cdr + ); + }; + +#endif /* end #if !defined */ +} + +// TAO_IDL - Generated from +// be\be_visitor_exception/any_op_ch.cpp:52 + +TAO_IMR_Client_Export void operator<<= (CORBA::Any &, const ImplementationRepository::AlreadyRegistered &); // copying version +TAO_IMR_Client_Export void operator<<= (CORBA::Any &, ImplementationRepository::AlreadyRegistered*); // noncopying version +TAO_IMR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::AlreadyRegistered *&); // deprecated +TAO_IMR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const ImplementationRepository::AlreadyRegistered *&); + +// TAO_IDL - Generated from +// be\be_visitor_exception/any_op_ch.cpp:52 + +TAO_IMR_Client_Export void operator<<= (CORBA::Any &, const ImplementationRepository::CannotActivate &); // copying version +TAO_IMR_Client_Export void operator<<= (CORBA::Any &, ImplementationRepository::CannotActivate*); // noncopying version +TAO_IMR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::CannotActivate *&); // deprecated +TAO_IMR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const ImplementationRepository::CannotActivate *&); + +// TAO_IDL - Generated from +// be\be_visitor_exception/any_op_ch.cpp:52 + +TAO_IMR_Client_Export void operator<<= (CORBA::Any &, const ImplementationRepository::NotFound &); // copying version +TAO_IMR_Client_Export void operator<<= (CORBA::Any &, ImplementationRepository::NotFound*); // noncopying version +TAO_IMR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::NotFound *&); // deprecated +TAO_IMR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const ImplementationRepository::NotFound *&); + +// TAO_IDL - Generated from +// be\be_visitor_structure/any_op_ch.cpp:52 + +TAO_IMR_Client_Export void operator<<= (CORBA::Any &, const ImplementationRepository::EnvironmentVariable &); // copying version +TAO_IMR_Client_Export void operator<<= (CORBA::Any &, ImplementationRepository::EnvironmentVariable*); // noncopying version +TAO_IMR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::EnvironmentVariable *&); // deprecated +TAO_IMR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const ImplementationRepository::EnvironmentVariable *&); + +// TAO_IDL - Generated from +// be\be_visitor_sequence/any_op_ch.cpp:52 + +TAO_IMR_Client_Export void operator<<= (CORBA::Any &, const ImplementationRepository::EnvironmentList &); // copying version +TAO_IMR_Client_Export void operator<<= (CORBA::Any &, ImplementationRepository::EnvironmentList*); // noncopying version +TAO_IMR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::EnvironmentList *&); // deprecated +TAO_IMR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const ImplementationRepository::EnvironmentList *&); + +// TAO_IDL - Generated from +// be\be_visitor_enum/any_op_ch.cpp:51 + +TAO_IMR_Client_Export void operator<<= (CORBA::Any &, ImplementationRepository::ActivationMode); +TAO_IMR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::ActivationMode &); + +// TAO_IDL - Generated from +// be\be_visitor_structure/any_op_ch.cpp:52 + +TAO_IMR_Client_Export void operator<<= (CORBA::Any &, const ImplementationRepository::StartupOptions &); // copying version +TAO_IMR_Client_Export void operator<<= (CORBA::Any &, ImplementationRepository::StartupOptions*); // noncopying version +TAO_IMR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::StartupOptions *&); // deprecated +TAO_IMR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const ImplementationRepository::StartupOptions *&); + +// TAO_IDL - Generated from +// be\be_visitor_structure/any_op_ch.cpp:52 + +TAO_IMR_Client_Export void operator<<= (CORBA::Any &, const ImplementationRepository::ServerInformation &); // copying version +TAO_IMR_Client_Export void operator<<= (CORBA::Any &, ImplementationRepository::ServerInformation*); // noncopying version +TAO_IMR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::ServerInformation *&); // deprecated +TAO_IMR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const ImplementationRepository::ServerInformation *&); + +// TAO_IDL - Generated from +// be\be_visitor_sequence/any_op_ch.cpp:52 + +TAO_IMR_Client_Export void operator<<= (CORBA::Any &, const ImplementationRepository::ServerInformationList &); // copying version +TAO_IMR_Client_Export void operator<<= (CORBA::Any &, ImplementationRepository::ServerInformationList*); // noncopying version +TAO_IMR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::ServerInformationList *&); // deprecated +TAO_IMR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const ImplementationRepository::ServerInformationList *&); + +// TAO_IDL - Generated from +// be\be_visitor_interface/any_op_ch.cpp:52 + +TAO_IMR_Client_Export void operator<<= (CORBA::Any &, ImplementationRepository::ServerInformationIterator_ptr); // copying +TAO_IMR_Client_Export void operator<<= (CORBA::Any &, ImplementationRepository::ServerInformationIterator_ptr *); // non-copying +TAO_IMR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::ServerInformationIterator_ptr &); + +// TAO_IDL - Generated from +// be\be_visitor_interface/any_op_ch.cpp:52 + +TAO_IMR_Client_Export void operator<<= (CORBA::Any &, ImplementationRepository::Administration_ptr); // copying +TAO_IMR_Client_Export void operator<<= (CORBA::Any &, ImplementationRepository::Administration_ptr *); // non-copying +TAO_IMR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::Administration_ptr &); + +// TAO_IDL - Generated from +// be\be_visitor_exception/cdr_op_ch.cpp:52 + +TAO_IMR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::AlreadyRegistered &); +TAO_IMR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::AlreadyRegistered &); + +// TAO_IDL - Generated from +// be\be_visitor_exception/cdr_op_ch.cpp:52 + +TAO_IMR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::CannotActivate &); +TAO_IMR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::CannotActivate &); + +// TAO_IDL - Generated from +// be\be_visitor_exception/cdr_op_ch.cpp:52 + +TAO_IMR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::NotFound &); +TAO_IMR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::NotFound &); + +// TAO_IDL - Generated from +// be\be_visitor_structure/cdr_op_ch.cpp:54 + +TAO_IMR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::EnvironmentVariable &); +TAO_IMR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::EnvironmentVariable &); + +// TAO_IDL - Generated from +// be\be_visitor_sequence/cdr_op_ch.cpp:71 + +#if !defined _TAO_CDR_OP_ImplementationRepository_EnvironmentList_H_ +#define _TAO_CDR_OP_ImplementationRepository_EnvironmentList_H_ + +TAO_IMR_Client_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, + const ImplementationRepository::EnvironmentList & + ); +TAO_IMR_Client_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, + ImplementationRepository::EnvironmentList & + ); + +#endif /* _TAO_CDR_OP_ImplementationRepository_EnvironmentList_H_ */ + +// TAO_IDL - Generated from +// be\be_visitor_enum/cdr_op_ch.cpp:50 + +TAO_IMR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::ActivationMode &); +TAO_IMR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::ActivationMode &); + +// TAO_IDL - Generated from +// be\be_visitor_structure/cdr_op_ch.cpp:54 + +TAO_IMR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::StartupOptions &); +TAO_IMR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::StartupOptions &); + +// TAO_IDL - Generated from +// be\be_visitor_structure/cdr_op_ch.cpp:54 + +TAO_IMR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::ServerInformation &); +TAO_IMR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::ServerInformation &); + +// TAO_IDL - Generated from +// be\be_visitor_sequence/cdr_op_ch.cpp:71 + +#if !defined _TAO_CDR_OP_ImplementationRepository_ServerInformationList_H_ +#define _TAO_CDR_OP_ImplementationRepository_ServerInformationList_H_ + +TAO_IMR_Client_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, + const ImplementationRepository::ServerInformationList & + ); +TAO_IMR_Client_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, + ImplementationRepository::ServerInformationList & + ); + +#endif /* _TAO_CDR_OP_ImplementationRepository_ServerInformationList_H_ */ + +// TAO_IDL - Generated from +// be\be_visitor_interface/cdr_op_ch.cpp:55 + +TAO_IMR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::ServerInformationIterator_ptr ); +TAO_IMR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::ServerInformationIterator_ptr &); + +// TAO_IDL - Generated from +// be\be_visitor_interface/cdr_op_ch.cpp:55 + +TAO_IMR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::Administration_ptr ); +TAO_IMR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::Administration_ptr &); + +// TAO_IDL - Generated from +// be\be_codegen.cpp:961 + +#if defined (__ACE_INLINE__) +#include "ImplRepoC.inl" +#endif /* defined INLINE */ + +#if defined(_MSC_VER) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option pop +#endif /* __BORLANDC__ */ + +#include /**/ "ace/post.h" + +#endif /* ifndef */ + + diff --git a/TAO/tao/ImR_Client/ImplRepoC.inl b/TAO/tao/ImR_Client/ImplRepoC.inl new file mode 100644 index 00000000000..7b37ccdeaac --- /dev/null +++ b/TAO/tao/ImR_Client/ImplRepoC.inl @@ -0,0 +1,99 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// and +// Institute for Software Integrated Systems +// Vanderbilt University +// Nashville, TN +// USA +// http://www.isis.vanderbilt.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + + +// TAO_IDL - Generated from +// be\be_visitor_interface/interface_ci.cpp:70 + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR___CI_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR___CI_ + +ACE_INLINE +ImplementationRepository::ServerInformationIterator::ServerInformationIterator ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated, + TAO_Abstract_ServantBase *servant, + TAO_ORB_Core *oc + ) + : ACE_NESTED_CLASS (CORBA, Object) ( + objref, + _tao_collocated, + servant, + oc + ), + the_TAO_ServerInformationIterator_Proxy_Broker_ (0) +{ + this->ImplementationRepository_ServerInformationIterator_setup_collocation (); +} + +ACE_INLINE +ImplementationRepository::ServerInformationIterator::ServerInformationIterator ( + IOP::IOR *ior, + TAO_ORB_Core *oc + ) + : ACE_NESTED_CLASS (CORBA, Object) (ior, oc), + the_TAO_ServerInformationIterator_Proxy_Broker_ (0) +{ +} + +#endif /* end #if !defined */ + +// TAO_IDL - Generated from +// be\be_visitor_interface/interface_ci.cpp:70 + +#if !defined (_IMPLEMENTATIONREPOSITORY_ADMINISTRATION___CI_) +#define _IMPLEMENTATIONREPOSITORY_ADMINISTRATION___CI_ + +ACE_INLINE +ImplementationRepository::Administration::Administration ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated, + TAO_Abstract_ServantBase *servant, + TAO_ORB_Core *oc + ) + : ACE_NESTED_CLASS (CORBA, Object) ( + objref, + _tao_collocated, + servant, + oc + ), + the_TAO_Administration_Proxy_Broker_ (0) +{ + this->ImplementationRepository_Administration_setup_collocation (); +} + +ACE_INLINE +ImplementationRepository::Administration::Administration ( + IOP::IOR *ior, + TAO_ORB_Core *oc + ) + : ACE_NESTED_CLASS (CORBA, Object) (ior, oc), + the_TAO_Administration_Proxy_Broker_ (0) +{ +} + +#endif /* end #if !defined */ diff --git a/TAO/tao/ImR_Client/ImplRepoS.cpp b/TAO/tao/ImR_Client/ImplRepoS.cpp new file mode 100644 index 00000000000..cdc16592d52 --- /dev/null +++ b/TAO/tao/ImR_Client/ImplRepoS.cpp @@ -0,0 +1,5241 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// and +// Institute for Software Integrated Systems +// Vanderbilt University +// Nashville, TN +// USA +// http://www.isis.vanderbilt.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + + +// TAO_IDL - Generated from +// be\be_codegen.cpp:609 + +#ifndef _TAO_IDL_ORIG_IMPLREPOS_CPP_ +#define _TAO_IDL_ORIG_IMPLREPOS_CPP_ + + +#include "ImplRepoS.h" +#include "tao/PortableServer/Servant_Upcall.h" +#include "tao/PortableServer/ForwardRequestC.h" +#include "tao/PortableServer/Operation_Table.h" +#include "tao/TAO_Server_Request.h" +#include "tao/ORB_Core.h" +#include "tao/Profile.h" +#include "tao/Stub.h" +#include "tao/IFR_Client_Adapter.h" +#include "tao/Object_T.h" +#include "tao/Typecode.h" +#include "tao/DynamicC.h" +#include "tao/CDR.h" +#include "tao/Basic_Arguments.h" +#include "tao/Object_Argument_T.h" +#include "tao/Special_Basic_Arguments.h" +#include "tao/UB_String_Arguments.h" +#include "tao/Var_Size_Argument_T.h" +#include "tao/PortableInterceptor.h" +#if TAO_HAS_INTERCEPTORS == 1 +#include "tao/PortableServer/PICurrent_Guard.h" +#include "tao/PortableServer/ServerRequestInfo.h" +#include "tao/PortableServer/ServerInterceptorAdapter.h" +#include "tao/RequestInfo_Util.h" +#endif /* TAO_HAS_INTERCEPTORS == 1 */ + +#include "ace/Dynamic_Service.h" +#include "ace/Malloc_Allocator.h" + +#if defined (__BORLANDC__) +#pragma option -w-rvl -w-rch -w-ccc -w-aus +#endif /* __BORLANDC__ */ + +#if !defined (__ACE_INLINE__) +#include "ImplRepoS.inl" +#endif /* !defined INLINE */ + +// TAO_IDL - Generated from +// be\be_visitor_arg_traits.cpp:66 + +// Arg traits specializations. +namespace TAO +{ + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVEROBJECT__ARG_TRAITS_SS_) +#define _IMPLEMENTATIONREPOSITORY_SERVEROBJECT__ARG_TRAITS_SS_ + + ACE_TEMPLATE_SPECIALIZATION + class TAO_IMR_Client_Export Arg_Traits<ImplementationRepository::ServerObject> + : public + Object_Arg_Traits_T< + ImplementationRepository::ServerObject_ptr, + ImplementationRepository::ServerObject_var, + ImplementationRepository::ServerObject_out, + TAO::Objref_Traits<ImplementationRepository::ServerObject> + > + { + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be\be_visitor_arg_traits.cpp:662 + +#if !defined (_IMPLEMENTATIONREPOSITORY_STARTUPOPTIONS__ARG_TRAITS_SS_) +#define _IMPLEMENTATIONREPOSITORY_STARTUPOPTIONS__ARG_TRAITS_SS_ + + ACE_TEMPLATE_SPECIALIZATION + class TAO_IMR_Client_Export Arg_Traits<ImplementationRepository::StartupOptions> + : public + Var_Size_Arg_Traits_T< + ImplementationRepository::StartupOptions, + ImplementationRepository::StartupOptions_var, + ImplementationRepository::StartupOptions_out + > + { + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be\be_visitor_arg_traits.cpp:662 + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATION__ARG_TRAITS_SS_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATION__ARG_TRAITS_SS_ + + ACE_TEMPLATE_SPECIALIZATION + class TAO_IMR_Client_Export Arg_Traits<ImplementationRepository::ServerInformation> + : public + Var_Size_Arg_Traits_T< + ImplementationRepository::ServerInformation, + ImplementationRepository::ServerInformation_var, + ImplementationRepository::ServerInformation_out + > + { + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be\be_visitor_arg_traits.cpp:433 + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST__ARG_TRAITS_SS_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST__ARG_TRAITS_SS_ + + ACE_TEMPLATE_SPECIALIZATION + class TAO_IMR_Client_Export Arg_Traits<ImplementationRepository::ServerInformationList> + : public + Var_Size_Arg_Traits_T< + ImplementationRepository::ServerInformationList, + ImplementationRepository::ServerInformationList_var, + ImplementationRepository::ServerInformationList_out + > + { + }; + +#endif /* end #if !defined */ + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR__ARG_TRAITS_SS_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR__ARG_TRAITS_SS_ + + ACE_TEMPLATE_SPECIALIZATION + class TAO_IMR_Client_Export Arg_Traits<ImplementationRepository::ServerInformationIterator> + : public + Object_Arg_Traits_T< + ImplementationRepository::ServerInformationIterator_ptr, + ImplementationRepository::ServerInformationIterator_var, + ImplementationRepository::ServerInformationIterator_out, + TAO::Objref_Traits<ImplementationRepository::ServerInformationIterator> + > + { + }; + +#endif /* end #if !defined */ +} + + +// TAO_IDL - Generated from +// be\be_interface.cpp:1536 + +class TAO_ImplementationRepository_ServerInformationIterator_Perfect_Hash_OpTable + : public TAO_Perfect_Hash_OpTable +{ +private: + unsigned int hash (const char *str, unsigned int len); + +public: + const TAO_operation_db_entry * lookup (const char *str, unsigned int len); +}; + +/* C++ code produced by gperf version 2.8 (ACE version) */ +/* Command-line: c:\ace\POArefactor3\ace_wrappers\bin\gperf.exe -m -M -J -c -C -D -E -T -f 0 -F 0,0,0 -a -o -t -p -K opname_ -L C++ -Z TAO_ImplementationRepository_ServerInformationIterator_Perfect_Hash_OpTable -N lookup */ +unsigned int +TAO_ImplementationRepository_ServerInformationIterator_Perfect_Hash_OpTable::hash (const char *str, unsigned int len) +{ + static const unsigned char asso_values[] = + { +#if defined (ACE_MVS) + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 0, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 0, + 16, 16, 0, 5, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 0, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 0, 16, 16, 16, 16, 0, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, +#else + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 0, 16, 0, 16, 16, + 0, 5, 16, 16, 16, 16, 16, 16, 16, 16, + 0, 16, 16, 16, 16, 16, 0, 16, 16, 16, + 16, 0, 16, 16, 16, 16, 16, 16, +#endif /* ACE_MVS */ + }; + return len + asso_values[(int) str[len - 1]] + asso_values[(int) str[0]]; +} + +const class TAO_operation_db_entry * +TAO_ImplementationRepository_ServerInformationIterator_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len) +{ + enum + { + TOTAL_KEYWORDS = 6, + MIN_WORD_LENGTH = 5, + MAX_WORD_LENGTH = 13, + MIN_HASH_VALUE = 5, + MAX_HASH_VALUE = 15, + HASH_VALUE_RANGE = 11, + DUPLICATES = 0, + WORDLIST_SIZE = 11 + }; + + static const class TAO_operation_db_entry wordlist[] = + { + {"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0}, + {"_is_a", &POA_ImplementationRepository::ServerInformationIterator::_is_a_skel, 0, 0}, + {"next_n", &POA_ImplementationRepository::ServerInformationIterator::next_n_skel, &POA_ImplementationRepository::_TAO_ServerInformationIterator_ThruPOA_Proxy_Impl::next_n, &POA_ImplementationRepository::_TAO_ServerInformationIterator_Direct_Proxy_Impl::next_n}, + {"destroy", &POA_ImplementationRepository::ServerInformationIterator::destroy_skel, &POA_ImplementationRepository::_TAO_ServerInformationIterator_ThruPOA_Proxy_Impl::destroy, &POA_ImplementationRepository::_TAO_ServerInformationIterator_Direct_Proxy_Impl::destroy}, + {"",0,0,0},{"",0,0,0}, + {"_component", &POA_ImplementationRepository::ServerInformationIterator::_component_skel, 0, 0}, + {"",0,0,0},{"",0,0,0}, + {"_non_existent", &POA_ImplementationRepository::ServerInformationIterator::_non_existent_skel, 0, 0}, + {"",0,0,0}, + {"_interface", &POA_ImplementationRepository::ServerInformationIterator::_interface_skel, 0, 0}, + }; + + if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH) + { + unsigned int key = hash (str, len); + + if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE) + { + const char *s = wordlist[key].opname_; + + if (*str == *s && !strncmp (str + 1, s + 1, len - 1)) + return &wordlist[key]; + } + } + return 0; +} + +static TAO_ImplementationRepository_ServerInformationIterator_Perfect_Hash_OpTable tao_ImplementationRepository_ServerInformationIterator_optable; + +// TAO_IDL - Generated from +// be\be_visitor_interface/interceptors_ss.cpp:53 + +#if (TAO_HAS_INTERCEPTORS == 1) + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:74 + +class TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_next_n : public TAO_ServerRequestInfo +{ +public: + TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_next_n ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *tao_servant_upcall, + POA_ImplementationRepository::ServerInformationIterator *tao_impl, + const ::CORBA::ULong & how_many + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + virtual Dynamic::ParameterList * arguments ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual Dynamic::ExceptionList * exceptions ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Any * result ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual char * target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Boolean target_is_a ( + const char * id + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void result (CORBA::Boolean result); + +private: + TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_next_n ( + const TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_next_n & + ); + + void operator= ( + const TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_next_n & + ); + +private: + POA_ImplementationRepository::ServerInformationIterator *_tao_impl; + + const ::CORBA::ULong & how_many_; + CORBA::Boolean _result; +}; + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:438 + +TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_next_n::TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_next_n ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *_tao_servant_upcall, + POA_ImplementationRepository::ServerInformationIterator *tao_impl, + const ::CORBA::ULong & how_many + ACE_ENV_ARG_DECL_NOT_USED + ) + : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall), + _tao_impl (tao_impl), + how_many_ (how_many) +{} + +Dynamic::ParameterList * +TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_next_n::arguments ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the argument list on demand. + Dynamic::ParameterList *parameter_list = + TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + Dynamic::ParameterList_var safe_parameter_list = parameter_list; + parameter_list->length (1); + CORBA::ULong len = 0; + + (*parameter_list)[len].argument <<= how_many_; + (*parameter_list)[len].mode = CORBA::PARAM_IN; + len++; + + return safe_parameter_list._retn (); +} + +Dynamic::ExceptionList * +TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_next_n::exceptions ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the exception list on demand. + Dynamic::ExceptionList *exception_list = + TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + return exception_list; +} + +CORBA::Any * +TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_next_n::result ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the result on demand. + CORBA::Boolean tk_void_any = 0; + CORBA::Any *result_any = + TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + CORBA::Any_var safe_result_any = result_any; + + (*result_any) <<= CORBA::Any::from_boolean (this->_result); + + return safe_result_any._retn (); +} + +char * +TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_next_n::target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_NOT_USED + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return + CORBA::string_dup (this->_tao_impl->_interface_repository_id ()); +} + +CORBA::Boolean +TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_next_n::target_is_a ( + const char * id + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER); +} + +void +TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_next_n::result (CORBA::Boolean result) +{ + // Update the result. + this->_result = result; +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:74 + +class TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_destroy : public TAO_ServerRequestInfo +{ +public: + TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_destroy ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *tao_servant_upcall, + POA_ImplementationRepository::ServerInformationIterator *tao_impl + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + virtual Dynamic::ParameterList * arguments ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual Dynamic::ExceptionList * exceptions ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Any * result ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual char * target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Boolean target_is_a ( + const char * id + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_destroy ( + const TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_destroy & + ); + + void operator= ( + const TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_destroy & + ); + +private: + POA_ImplementationRepository::ServerInformationIterator *_tao_impl; + +}; + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:438 + +TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_destroy::TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_destroy ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *_tao_servant_upcall, + POA_ImplementationRepository::ServerInformationIterator *tao_impl + ACE_ENV_ARG_DECL_NOT_USED + ) + : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall), + _tao_impl (tao_impl) +{} + +Dynamic::ParameterList * +TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_destroy::arguments ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the argument list on demand. + Dynamic::ParameterList *parameter_list = + TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + return parameter_list; +} + +Dynamic::ExceptionList * +TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_destroy::exceptions ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the exception list on demand. + Dynamic::ExceptionList *exception_list = + TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + return exception_list; +} + +CORBA::Any * +TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_destroy::result ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the result on demand. + CORBA::Boolean tk_void_any = 1; + CORBA::Any *result_any = + TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + return result_any; +} + +char * +TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_destroy::target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_NOT_USED + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return + CORBA::string_dup (this->_tao_impl->_interface_repository_id ()); +} + +CORBA::Boolean +TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_destroy::target_is_a ( + const char * id + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER); +} + +#endif /* TAO_HAS_INTERCEPTORS */ + +/////////////////////////////////////////////////////////////////////// +// Strategized Proxy Broker Implementation +// + +// TAO_IDL - Generated from +// be\be_visitor_interface/strategized_proxy_broker_ss.cpp:40 + +// Factory function Implementation. +POA_ImplementationRepository::_TAO_ServerInformationIterator_Strategized_Proxy_Broker * +POA_ImplementationRepository::_TAO_ServerInformationIterator_Strategized_Proxy_Broker::the_TAO_ServerInformationIterator_Strategized_Proxy_Broker (void) +{ + static POA_ImplementationRepository::_TAO_ServerInformationIterator_Strategized_Proxy_Broker + strategized_proxy_broker; + + return &strategized_proxy_broker; +} + +POA_ImplementationRepository::_TAO_ServerInformationIterator_Strategized_Proxy_Broker::_TAO_ServerInformationIterator_Strategized_Proxy_Broker (void) +{ +} + +POA_ImplementationRepository::_TAO_ServerInformationIterator_Strategized_Proxy_Broker::~_TAO_ServerInformationIterator_Strategized_Proxy_Broker (void) +{ +} + +TAO::Collocation_Strategy +POA_ImplementationRepository::_TAO_ServerInformationIterator_Strategized_Proxy_Broker::get_strategy ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + TAO::Collocation_Strategy strategy = + TAO_ORB_Core::collocation_strategy (obj ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (TAO::TAO_CS_REMOTE_STRATEGY); + + return strategy; +} + +void +POA_ImplementationRepository::_TAO_ServerInformationIterator_Strategized_Proxy_Broker::dispatch ( + CORBA::Object_ptr obj, + CORBA::Object_out forward_obj, + TAO::Argument ** args, + int num_args, + const char * op, + size_t op_len, + TAO::Collocation_Strategy strategy + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::Exception)) +{ + TAO::Portable_Server::Servant_Upcall servant_upcall ( + obj->_stubobj ()->servant_orb_var ()->orb_core () + ); + + TAO_Collocated_Skeleton collocated_skel; + TAO_Abstract_ServantBase *servant = 0; + + if (strategy == TAO::TAO_CS_THRU_POA_STRATEGY) + { + servant_upcall.prepare_for_upcall ( + obj->_stubobj ()->object_key (), + op, + forward_obj + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; + + servant_upcall.pre_invoke_collocated_request ( + ACE_ENV_SINGLE_ARG_PARAMETER + ); + ACE_CHECK; + + servant = servant_upcall.servant (); + } + else + { + servant = obj->_servant (); + } + + int status = servant->_find (op, + collocated_skel, + strategy, + op_len); + + if (status == -1) + { + ACE_THROW (CORBA::BAD_OPERATION (TAO::VMCID | 2, CORBA::COMPLETED_NO)); + } + + ACE_TRY + { + collocated_skel (servant, + args, + num_args + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } +#if (TAO_HAS_MINIMUM_CORBA == 0) + ACE_CATCH (PortableServer::ForwardRequest, forward_request) + { + forward_obj = + CORBA::Object::_duplicate (forward_request.forward_reference.in ()); + return; + } +#else + ACE_CATCHANY + { + ACE_UNUSED_ARG (forward_obj); + ACE_RE_THROW; + } +#endif /* TAO_HAS_MINIMUM_CORBA */ + ACE_ENDTRY; + ACE_CHECK; +} + +// +// End Strategized Proxy Broker Implementation +/////////////////////////////////////////////////////////////////////// + +// TAO_IDL - Generated from +// be\be_visitor_interface/interface_ss.cpp:640 + +TAO::Collocation_Proxy_Broker * +ImplementationRepository__TAO_ServerInformationIterator_Proxy_Broker_Factory_function (CORBA::Object_ptr) +{ + return + ::POA_ImplementationRepository::_TAO_ServerInformationIterator_Strategized_Proxy_Broker::the_TAO_ServerInformationIterator_Strategized_Proxy_Broker (); +} + +int +ImplementationRepository__TAO_ServerInformationIterator_Proxy_Broker_Factory_Initializer (size_t) +{ + ImplementationRepository__TAO_ServerInformationIterator_Proxy_Broker_Factory_function_pointer = + ImplementationRepository__TAO_ServerInformationIterator_Proxy_Broker_Factory_function; + + return 0; +} + +static int +ImplementationRepository__TAO_ServerInformationIterator_Proxy_Broker_Stub_Factory_Initializer_Scarecrow = + ImplementationRepository__TAO_ServerInformationIterator_Proxy_Broker_Factory_Initializer ( + reinterpret_cast< + size_t> ( + ImplementationRepository__TAO_ServerInformationIterator_Proxy_Broker_Factory_Initializer + ) + ); + + +/////////////////////////////////////////////////////////////////////// +// ThruPOA Proxy Implementation +// + +// TAO_IDL - Generated from +// be\be_visitor_interface/thru_poa_proxy_impl_ss.cpp:37 + +POA_ImplementationRepository::_TAO_ServerInformationIterator_ThruPOA_Proxy_Impl::_TAO_ServerInformationIterator_ThruPOA_Proxy_Impl (void) +{} + +// ThruPOA Implementation of the IDL interface methods + +// TAO_IDL - Generated from +// be\be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52 + +void +POA_ImplementationRepository::_TAO_ServerInformationIterator_ThruPOA_Proxy_Impl::next_n ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + ((TAO::Arg_Traits< ::ACE_InputCDR::to_boolean>::ret_val *) args[0])->arg () = + reinterpret_cast< + POA_ImplementationRepository::ServerInformationIterator_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/ServerInformationIterator:1.0" + ) + )->next_n ( + ((TAO::Arg_Traits< ::CORBA::ULong>::in_arg_val *) args[1])->arg (), + ((TAO::Arg_Traits< ImplementationRepository::ServerInformationList>::out_arg_val *) args[2])->arg () + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52 + +void +POA_ImplementationRepository::_TAO_ServerInformationIterator_ThruPOA_Proxy_Impl::destroy ( + TAO_Abstract_ServantBase *servant, + TAO::Argument **, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + reinterpret_cast< + POA_ImplementationRepository::ServerInformationIterator_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/ServerInformationIterator:1.0" + ) + )->destroy ( + ACE_ENV_SINGLE_ARG_PARAMETER + ); + ACE_CHECK; +} + +// +// End ThruPOA Proxy Implementation +/////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////// +// Direct Proxy Implementation +// + +POA_ImplementationRepository::_TAO_ServerInformationIterator_Direct_Proxy_Impl::_TAO_ServerInformationIterator_Direct_Proxy_Impl (void) +{} + +// TAO_IDL - Generated from +// be\be_visitor_operation/direct_proxy_impl_ss.cpp:42 + +void +POA_ImplementationRepository::_TAO_ServerInformationIterator_Direct_Proxy_Impl::next_n ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + ((TAO::Arg_Traits< ::ACE_InputCDR::to_boolean>::ret_val *) args[0])->arg () = + reinterpret_cast< + POA_ImplementationRepository::ServerInformationIterator_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/ServerInformationIterator:1.0" + ) + )->next_n ( + ((TAO::Arg_Traits< ::CORBA::ULong>::in_arg_val *) args[1])->arg (), + ((TAO::Arg_Traits< ImplementationRepository::ServerInformationList>::out_arg_val *) args[2])->arg () + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +}// TAO_IDL - Generated from +// be\be_visitor_operation/direct_proxy_impl_ss.cpp:42 + +void +POA_ImplementationRepository::_TAO_ServerInformationIterator_Direct_Proxy_Impl::destroy ( + TAO_Abstract_ServantBase *servant, + TAO::Argument **, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + reinterpret_cast< + POA_ImplementationRepository::ServerInformationIterator_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/ServerInformationIterator:1.0" + ) + )->destroy ( + ACE_ENV_SINGLE_ARG_PARAMETER + ); + ACE_CHECK; +} + +// +// End Direct Proxy Implementation +/////////////////////////////////////////////////////////////////////// + +// TAO_IDL - Generated from +// be\be_visitor_interface/interface_ss.cpp:97 + +POA_ImplementationRepository::ServerInformationIterator::ServerInformationIterator (void) +{ + this->optable_ = &tao_ImplementationRepository_ServerInformationIterator_optable; +} + +POA_ImplementationRepository::ServerInformationIterator::ServerInformationIterator (const ServerInformationIterator& rhs) + : TAO_Abstract_ServantBase (rhs), + TAO_ServantBase (rhs) +{ +} + +POA_ImplementationRepository::ServerInformationIterator::~ServerInformationIterator (void) +{ +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_ss.cpp:98 + +void POA_ImplementationRepository::ServerInformationIterator::next_n_skel ( + TAO_ServerRequest &_tao_server_request, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_ImplementationRepository::ServerInformationIterator *_tao_impl = + static_cast< + POA_ImplementationRepository::ServerInformationIterator *> ( + _tao_servant + ); + CORBA::Boolean _tao_retval = 0; + ::CORBA::ULong how_many; + ::ImplementationRepository::ServerInformationList_var servers; + + + if (!( + (_tao_in >> how_many) + )) + { + TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + +#if (TAO_HAS_INTERCEPTORS == 1) + TAO::Portable_Server::Servant_Upcall *_tao_upcall = + static_cast< + TAO::Portable_Server::Servant_Upcall *> ( + _tao_servant_upcall + ); + + TAO_ServerRequestInterceptor_Adapter _tao_vfr ( + _tao_server_request.orb_core ()->server_request_interceptors (), + _tao_server_request.interceptor_count () + ); + + TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_next_n _tao_ri ( + _tao_server_request, + _tao_upcall, + _tao_impl, + + how_many + ACE_ENV_ARG_PARAMETER + ); + + ACE_TRY + { + { + TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (), + true /* Copy TSC to RSC */); + + _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (!_tao_vfr.location_forwarded ()) + { +#endif /* TAO_HAS_INTERCEPTORS */ + _tao_retval = + _tao_impl->next_n ( + how_many, + + servers.out () + ACE_ENV_ARG_PARAMETER + ); + TAO_INTERCEPTOR_CHECK; +#if (TAO_HAS_INTERCEPTORS == 1) + } + } + + if (!_tao_vfr.location_forwarded ()) + { + CORBA::Boolean _tao_retval_info = _tao_retval; + _tao_ri.result (_tao_retval_info); + _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL); + _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + } + ACE_CATCHANY + { + _tao_ri.exception (&ACE_ANY_EXCEPTION); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION + || _tao_status == PortableInterceptor::USER_EXCEPTION) + { + ACE_RE_THROW; + } + } + +# if defined (ACE_HAS_EXCEPTIONS) \ + && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS) + ACE_CATCHALL + { + CORBA::UNKNOWN ex; + + _tao_ri.exception (&ex); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION) + ACE_TRY_THROW (ex); + } +# endif /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */ + ACE_ENDTRY; + ACE_CHECK; +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_server_request.init_reply (); +#if (TAO_HAS_INTERCEPTORS == 1) + if (!_tao_vfr.location_forwarded ()) + { +#endif /* TAO_HAS_INTERCEPTORS */ + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + + if (!( + (_tao_out << CORBA::Any::from_boolean (_tao_retval)) && + (_tao_out << servers.in ()) + )) + { + TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } +#if (TAO_HAS_INTERCEPTORS == 1) + } +#endif /* TAO_HAS_INTERCEPTORS */ + + + // In case _tao_servant_upcall is not used in this function + ACE_UNUSED_ARG (_tao_servant_upcall); +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_ss.cpp:98 + +void POA_ImplementationRepository::ServerInformationIterator::destroy_skel ( + TAO_ServerRequest &_tao_server_request, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ) +{ + POA_ImplementationRepository::ServerInformationIterator *_tao_impl = + static_cast< + POA_ImplementationRepository::ServerInformationIterator *> ( + _tao_servant + ); + _tao_server_request.argument_flag (0); + + +#if (TAO_HAS_INTERCEPTORS == 1) + TAO::Portable_Server::Servant_Upcall *_tao_upcall = + static_cast< + TAO::Portable_Server::Servant_Upcall *> ( + _tao_servant_upcall + ); + + TAO_ServerRequestInterceptor_Adapter _tao_vfr ( + _tao_server_request.orb_core ()->server_request_interceptors (), + _tao_server_request.interceptor_count () + ); + + TAO_ServerRequestInfo_ImplementationRepository_ServerInformationIterator_destroy _tao_ri ( + _tao_server_request, + _tao_upcall, + _tao_impl + ACE_ENV_ARG_PARAMETER + ); + + ACE_TRY + { + { + TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (), + true /* Copy TSC to RSC */); + + _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (!_tao_vfr.location_forwarded ()) + { +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_impl->destroy ( + ACE_ENV_SINGLE_ARG_PARAMETER + ); + TAO_INTERCEPTOR_CHECK; +#if (TAO_HAS_INTERCEPTORS == 1) + } + } + + if (!_tao_vfr.location_forwarded ()) + { + _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL); + _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + } + ACE_CATCHANY + { + _tao_ri.exception (&ACE_ANY_EXCEPTION); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION + || _tao_status == PortableInterceptor::USER_EXCEPTION) + { + ACE_RE_THROW; + } + } + +# if defined (ACE_HAS_EXCEPTIONS) \ + && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS) + ACE_CATCHALL + { + CORBA::UNKNOWN ex; + + _tao_ri.exception (&ex); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION) + ACE_TRY_THROW (ex); + } +# endif /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */ + ACE_ENDTRY; + ACE_CHECK; +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_server_request.init_reply (); + + // In case _tao_servant_upcall is not used in this function + ACE_UNUSED_ARG (_tao_servant_upcall); +} + +// TAO_IDL - Generated from +// be\be_visitor_interface/interface_ss.cpp:162 + +void POA_ImplementationRepository::ServerInformationIterator::_is_a_skel ( + TAO_ServerRequest &_tao_server_request, + void * _tao_servant, + void * /* Servant_Upcall */ + ACE_ENV_ARG_DECL + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + + POA_ImplementationRepository::ServerInformationIterator *_tao_impl = + static_cast<POA_ImplementationRepository::ServerInformationIterator *> (_tao_servant); + + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + + if (!(_tao_in >> value.out ())) + { + ACE_THROW (CORBA::MARSHAL ()); + } + + _tao_retval = _tao_impl->_is_a (value.in () ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + _tao_server_request.init_reply (); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + + if (!(_tao_out << CORBA::Any::from_boolean (_tao_retval))) + { + ACE_THROW (CORBA::MARSHAL ()); + } +} + +void POA_ImplementationRepository::ServerInformationIterator::_non_existent_skel ( + TAO_ServerRequest &_tao_server_request, + void * _tao_servant, + void * /* Servant_Upcall */ + ACE_ENV_ARG_DECL + ) +{ + POA_ImplementationRepository::ServerInformationIterator *_tao_impl = + static_cast<POA_ImplementationRepository::ServerInformationIterator *> (_tao_servant); + + CORBA::Boolean _tao_retval = + _tao_impl->_non_existent (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + _tao_server_request.init_reply (); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + + if (!(_tao_out << CORBA::Any::from_boolean (_tao_retval))) + { + ACE_THROW (CORBA::MARSHAL ()); + } +} + +void POA_ImplementationRepository::ServerInformationIterator::_interface_skel ( + TAO_ServerRequest &_tao_server_request, + void * _tao_servant, + void * /* Servant_Upcall */ + ACE_ENV_ARG_DECL + ) +{ + TAO_IFR_Client_Adapter *_tao_adapter = + ACE_Dynamic_Service<TAO_IFR_Client_Adapter>::instance ( + TAO_ORB_Core::ifr_client_adapter_name () + ); + + if (_tao_adapter == 0) + { + ACE_THROW (CORBA::INTF_REPOS ()); + } + + POA_ImplementationRepository::ServerInformationIterator *_tao_impl = + static_cast<POA_ImplementationRepository::ServerInformationIterator *> (_tao_servant); + + CORBA::InterfaceDef_ptr _tao_retval = + _tao_impl->_get_interface (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + _tao_server_request.init_reply (); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + + CORBA::Boolean _tao_result = + _tao_adapter->interfacedef_cdr_insert ( + _tao_out, + _tao_retval + ); + + _tao_adapter->dispose (_tao_retval); + + if (_tao_result == 0) + { + ACE_THROW (CORBA::MARSHAL ()); + } +} + +void POA_ImplementationRepository::ServerInformationIterator::_component_skel ( + TAO_ServerRequest &_tao_server_request, + void * _tao_object_reference, + void * /* Servant_Upcall */ + ACE_ENV_ARG_DECL + ) +{ + POA_ImplementationRepository::ServerInformationIterator *_tao_impl = + static_cast<POA_ImplementationRepository::ServerInformationIterator *> (_tao_object_reference); + + CORBA::Object_var _tao_retval = + _tao_impl->_get_component (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + _tao_server_request.init_reply (); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + + if (!(_tao_out << _tao_retval.in ())) + { + ACE_THROW (CORBA::MARSHAL ()); + } +} + +CORBA::Boolean POA_ImplementationRepository::ServerInformationIterator::_is_a ( + const char* value + ACE_ENV_ARG_DECL_NOT_USED + ) +{ + return + ( + !ACE_OS::strcmp ( + value, + "IDL:ImplementationRepository/ServerInformationIterator:1.0" + ) || + !ACE_OS::strcmp ( + value, + "IDL:omg.org/CORBA/Object:1.0" + ) + ); +} + +void* POA_ImplementationRepository::ServerInformationIterator::_downcast ( + const char* logical_type_id + ) +{ + if (ACE_OS::strcmp (logical_type_id, + "IDL:ImplementationRepository/ServerInformationIterator:1.0") == 0) + { + return static_cast<POA_ImplementationRepository::ServerInformationIterator_ptr> (this); + } + + if (ACE_OS::strcmp (logical_type_id, + "IDL:omg.org/CORBA/Object:1.0") == 0) + { + return static_cast<PortableServer::Servant> (this); + } + + return 0; +} + +const char* POA_ImplementationRepository::ServerInformationIterator::_interface_repository_id (void) const +{ + return "IDL:ImplementationRepository/ServerInformationIterator:1.0"; +} + +// TAO_IDL - Generated from +// be\be_visitor_interface/interface_ss.cpp:576 + +void POA_ImplementationRepository::ServerInformationIterator::_dispatch ( + TAO_ServerRequest &req, + void *servant_upcall + ACE_ENV_ARG_DECL + ) +{ + this->synchronous_upcall_dispatch (req, + servant_upcall, + this + ACE_ENV_ARG_PARAMETER); +} + +// TAO_IDL - Generated from +// be\be_visitor_interface/interface_ss.cpp:527 + +ImplementationRepository::ServerInformationIterator * +POA_ImplementationRepository::ServerInformationIterator::_this (ACE_ENV_SINGLE_ARG_DECL) +{ + TAO_Stub *stub = this->_create_stub (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + TAO_Stub_Auto_Ptr safe_stub (stub); + CORBA::Object_ptr tmp = CORBA::Object::_nil (); + + CORBA::Boolean _tao_opt_colloc = + stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects (); + + ACE_NEW_RETURN ( + tmp, + CORBA::Object (stub, _tao_opt_colloc, this), + 0 + ); + + CORBA::Object_var obj = tmp; + (void) safe_stub.release (); + + typedef ::ImplementationRepository::ServerInformationIterator STUB_SCOPED_NAME; + return + TAO::Narrow_Utils<STUB_SCOPED_NAME>::unchecked_narrow ( + obj.in (), + ImplementationRepository__TAO_ServerInformationIterator_Proxy_Broker_Factory_function_pointer + ); +} + +// TAO_IDL - Generated from +// be\be_interface.cpp:1536 + +class TAO_ImplementationRepository_Administration_Perfect_Hash_OpTable + : public TAO_Perfect_Hash_OpTable +{ +private: + unsigned int hash (const char *str, unsigned int len); + +public: + const TAO_operation_db_entry * lookup (const char *str, unsigned int len); +}; + +/* C++ code produced by gperf version 2.8 (ACE version) */ +/* Command-line: c:\ace\POArefactor3\ace_wrappers\bin\gperf.exe -m -M -J -c -C -D -E -T -f 0 -F 0,0,0 -a -o -t -p -K opname_ -L C++ -Z TAO_ImplementationRepository_Administration_Perfect_Hash_OpTable -N lookup */ +unsigned int +TAO_ImplementationRepository_Administration_Perfect_Hash_OpTable::hash (const char *str, unsigned int len) +{ + static const unsigned char asso_values[] = + { +#if defined (ACE_MVS) + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 0, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 9, + 29, 29, 0, 0, 0, 5, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 5, 29, 0, + 29, 29, 29, 0, 29, 29, 29, 29, 29, 29, + 29, 29, 5, 9, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, +#else + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 0, 29, 9, 29, 29, + 0, 0, 0, 5, 29, 29, 29, 29, 5, 29, + 0, 29, 29, 29, 0, 5, 9, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, +#endif /* ACE_MVS */ + }; + return len + asso_values[(int) str[len - 1]] + asso_values[(int) str[0]]; +} + +const class TAO_operation_db_entry * +TAO_ImplementationRepository_Administration_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len) +{ + enum + { + TOTAL_KEYWORDS = 13, + MIN_WORD_LENGTH = 4, + MAX_WORD_LENGTH = 23, + MIN_HASH_VALUE = 4, + MAX_HASH_VALUE = 28, + HASH_VALUE_RANGE = 25, + DUPLICATES = 0, + WORDLIST_SIZE = 17 + }; + + static const class TAO_operation_db_entry wordlist[] = + { + {"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0}, + {"find", &POA_ImplementationRepository::Administration::find_skel, &POA_ImplementationRepository::_TAO_Administration_ThruPOA_Proxy_Impl::find, &POA_ImplementationRepository::_TAO_Administration_Direct_Proxy_Impl::find}, + {"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0}, + {"_interface", &POA_ImplementationRepository::Administration::_interface_skel, 0, 0}, + {"",0,0,0},{"",0,0,0}, + {"remove_server", &POA_ImplementationRepository::Administration::remove_server_skel, &POA_ImplementationRepository::_TAO_Administration_ThruPOA_Proxy_Impl::remove_server, &POA_ImplementationRepository::_TAO_Administration_Direct_Proxy_Impl::remove_server}, + {"_is_a", &POA_ImplementationRepository::Administration::_is_a_skel, 0, 0}, + {"register_server", &POA_ImplementationRepository::Administration::register_server_skel, &POA_ImplementationRepository::_TAO_Administration_ThruPOA_Proxy_Impl::register_server, &POA_ImplementationRepository::_TAO_Administration_Direct_Proxy_Impl::register_server}, + {"",0,0,0}, + {"reregister_server", &POA_ImplementationRepository::Administration::reregister_server_skel, &POA_ImplementationRepository::_TAO_Administration_ThruPOA_Proxy_Impl::reregister_server, &POA_ImplementationRepository::_TAO_Administration_Direct_Proxy_Impl::reregister_server}, + {"list", &POA_ImplementationRepository::Administration::list_skel, &POA_ImplementationRepository::_TAO_Administration_ThruPOA_Proxy_Impl::list, &POA_ImplementationRepository::_TAO_Administration_Direct_Proxy_Impl::list}, + {"_component", &POA_ImplementationRepository::Administration::_component_skel, 0, 0}, + {"shutdown_server", &POA_ImplementationRepository::Administration::shutdown_server_skel, &POA_ImplementationRepository::_TAO_Administration_ThruPOA_Proxy_Impl::shutdown_server, &POA_ImplementationRepository::_TAO_Administration_Direct_Proxy_Impl::shutdown_server}, + {"",0,0,0}, + {"_non_existent", &POA_ImplementationRepository::Administration::_non_existent_skel, 0, 0}, + {"",0,0,0}, + {"activate_server", &POA_ImplementationRepository::Administration::activate_server_skel, &POA_ImplementationRepository::_TAO_Administration_ThruPOA_Proxy_Impl::activate_server, &POA_ImplementationRepository::_TAO_Administration_Direct_Proxy_Impl::activate_server}, + {"",0,0,0},{"",0,0,0}, + {"server_is_running", &POA_ImplementationRepository::Administration::server_is_running_skel, &POA_ImplementationRepository::_TAO_Administration_ThruPOA_Proxy_Impl::server_is_running, &POA_ImplementationRepository::_TAO_Administration_Direct_Proxy_Impl::server_is_running}, + {"server_is_shutting_down", &POA_ImplementationRepository::Administration::server_is_shutting_down_skel, &POA_ImplementationRepository::_TAO_Administration_ThruPOA_Proxy_Impl::server_is_shutting_down, &POA_ImplementationRepository::_TAO_Administration_Direct_Proxy_Impl::server_is_shutting_down}, + }; + + if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH) + { + unsigned int key = hash (str, len); + + if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE) + { + const char *s = wordlist[key].opname_; + + if (*str == *s && !strncmp (str + 1, s + 1, len - 1)) + return &wordlist[key]; + } + } + return 0; +} + +static TAO_ImplementationRepository_Administration_Perfect_Hash_OpTable tao_ImplementationRepository_Administration_optable; + +// TAO_IDL - Generated from +// be\be_visitor_interface/interceptors_ss.cpp:53 + +#if (TAO_HAS_INTERCEPTORS == 1) + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:74 + +class TAO_ServerRequestInfo_ImplementationRepository_Administration_activate_server : public TAO_ServerRequestInfo +{ +public: + TAO_ServerRequestInfo_ImplementationRepository_Administration_activate_server ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *tao_servant_upcall, + POA_ImplementationRepository::Administration *tao_impl, + const char * server + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + virtual Dynamic::ParameterList * arguments ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual Dynamic::ExceptionList * exceptions ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Any * result ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual char * target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Boolean target_is_a ( + const char * id + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + TAO_ServerRequestInfo_ImplementationRepository_Administration_activate_server ( + const TAO_ServerRequestInfo_ImplementationRepository_Administration_activate_server & + ); + + void operator= ( + const TAO_ServerRequestInfo_ImplementationRepository_Administration_activate_server & + ); + +private: + POA_ImplementationRepository::Administration *_tao_impl; + + const char * server_; +}; + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:438 + +TAO_ServerRequestInfo_ImplementationRepository_Administration_activate_server::TAO_ServerRequestInfo_ImplementationRepository_Administration_activate_server ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *_tao_servant_upcall, + POA_ImplementationRepository::Administration *tao_impl, + const char * server + ACE_ENV_ARG_DECL_NOT_USED + ) + : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall), + _tao_impl (tao_impl), + server_ (server) +{} + +Dynamic::ParameterList * +TAO_ServerRequestInfo_ImplementationRepository_Administration_activate_server::arguments ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the argument list on demand. + Dynamic::ParameterList *parameter_list = + TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + Dynamic::ParameterList_var safe_parameter_list = parameter_list; + parameter_list->length (1); + CORBA::ULong len = 0; + + (*parameter_list)[len].argument <<= server_; + (*parameter_list)[len].mode = CORBA::PARAM_IN; + len++; + + return safe_parameter_list._retn (); +} + +Dynamic::ExceptionList * +TAO_ServerRequestInfo_ImplementationRepository_Administration_activate_server::exceptions ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the exception list on demand. + Dynamic::ExceptionList *exception_list = + TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + Dynamic::ExceptionList_var safe_exception_list = exception_list; + + static CORBA::TypeCode_ptr _tao_ImplementationRepository_Administration_activate_server_exceptiondata[] = + { + ImplementationRepository::_tc_NotFound, + ImplementationRepository::_tc_CannotActivate + }; + + exception_list->length (2); + for (CORBA::ULong i = 0; i < 2; ++i) + { + CORBA::TypeCode_ptr tcp = _tao_ImplementationRepository_Administration_activate_server_exceptiondata[i]; + TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1); + (*exception_list)[i] = tcp_object; + } + + return safe_exception_list._retn (); +} + +CORBA::Any * +TAO_ServerRequestInfo_ImplementationRepository_Administration_activate_server::result ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the result on demand. + CORBA::Boolean tk_void_any = 1; + CORBA::Any *result_any = + TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + return result_any; +} + +char * +TAO_ServerRequestInfo_ImplementationRepository_Administration_activate_server::target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_NOT_USED + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return + CORBA::string_dup (this->_tao_impl->_interface_repository_id ()); +} + +CORBA::Boolean +TAO_ServerRequestInfo_ImplementationRepository_Administration_activate_server::target_is_a ( + const char * id + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER); +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:74 + +class TAO_ServerRequestInfo_ImplementationRepository_Administration_register_server : public TAO_ServerRequestInfo +{ +public: + TAO_ServerRequestInfo_ImplementationRepository_Administration_register_server ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *tao_servant_upcall, + POA_ImplementationRepository::Administration *tao_impl, + const char * server, + const ::ImplementationRepository::StartupOptions & options + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + virtual Dynamic::ParameterList * arguments ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual Dynamic::ExceptionList * exceptions ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Any * result ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual char * target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Boolean target_is_a ( + const char * id + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + TAO_ServerRequestInfo_ImplementationRepository_Administration_register_server ( + const TAO_ServerRequestInfo_ImplementationRepository_Administration_register_server & + ); + + void operator= ( + const TAO_ServerRequestInfo_ImplementationRepository_Administration_register_server & + ); + +private: + POA_ImplementationRepository::Administration *_tao_impl; + + const char * server_; + const ::ImplementationRepository::StartupOptions & options_; +}; + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:438 + +TAO_ServerRequestInfo_ImplementationRepository_Administration_register_server::TAO_ServerRequestInfo_ImplementationRepository_Administration_register_server ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *_tao_servant_upcall, + POA_ImplementationRepository::Administration *tao_impl, + const char * server, + const ::ImplementationRepository::StartupOptions & options + ACE_ENV_ARG_DECL_NOT_USED + ) + : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall), + _tao_impl (tao_impl), + server_ (server), + options_ (options) +{} + +Dynamic::ParameterList * +TAO_ServerRequestInfo_ImplementationRepository_Administration_register_server::arguments ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the argument list on demand. + Dynamic::ParameterList *parameter_list = + TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + Dynamic::ParameterList_var safe_parameter_list = parameter_list; + parameter_list->length (2); + CORBA::ULong len = 0; + + (*parameter_list)[len].argument <<= server_; + (*parameter_list)[len].mode = CORBA::PARAM_IN; + len++; + + (*parameter_list)[len].argument <<= this->options_; + (*parameter_list)[len].mode = CORBA::PARAM_IN; + len++; + + return safe_parameter_list._retn (); +} + +Dynamic::ExceptionList * +TAO_ServerRequestInfo_ImplementationRepository_Administration_register_server::exceptions ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the exception list on demand. + Dynamic::ExceptionList *exception_list = + TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + Dynamic::ExceptionList_var safe_exception_list = exception_list; + + static CORBA::TypeCode_ptr _tao_ImplementationRepository_Administration_register_server_exceptiondata[] = + { + ImplementationRepository::_tc_AlreadyRegistered, + ImplementationRepository::_tc_NotFound + }; + + exception_list->length (2); + for (CORBA::ULong i = 0; i < 2; ++i) + { + CORBA::TypeCode_ptr tcp = _tao_ImplementationRepository_Administration_register_server_exceptiondata[i]; + TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1); + (*exception_list)[i] = tcp_object; + } + + return safe_exception_list._retn (); +} + +CORBA::Any * +TAO_ServerRequestInfo_ImplementationRepository_Administration_register_server::result ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the result on demand. + CORBA::Boolean tk_void_any = 1; + CORBA::Any *result_any = + TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + return result_any; +} + +char * +TAO_ServerRequestInfo_ImplementationRepository_Administration_register_server::target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_NOT_USED + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return + CORBA::string_dup (this->_tao_impl->_interface_repository_id ()); +} + +CORBA::Boolean +TAO_ServerRequestInfo_ImplementationRepository_Administration_register_server::target_is_a ( + const char * id + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER); +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:74 + +class TAO_ServerRequestInfo_ImplementationRepository_Administration_reregister_server : public TAO_ServerRequestInfo +{ +public: + TAO_ServerRequestInfo_ImplementationRepository_Administration_reregister_server ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *tao_servant_upcall, + POA_ImplementationRepository::Administration *tao_impl, + const char * server, + const ::ImplementationRepository::StartupOptions & options + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + virtual Dynamic::ParameterList * arguments ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual Dynamic::ExceptionList * exceptions ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Any * result ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual char * target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Boolean target_is_a ( + const char * id + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + TAO_ServerRequestInfo_ImplementationRepository_Administration_reregister_server ( + const TAO_ServerRequestInfo_ImplementationRepository_Administration_reregister_server & + ); + + void operator= ( + const TAO_ServerRequestInfo_ImplementationRepository_Administration_reregister_server & + ); + +private: + POA_ImplementationRepository::Administration *_tao_impl; + + const char * server_; + const ::ImplementationRepository::StartupOptions & options_; +}; + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:438 + +TAO_ServerRequestInfo_ImplementationRepository_Administration_reregister_server::TAO_ServerRequestInfo_ImplementationRepository_Administration_reregister_server ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *_tao_servant_upcall, + POA_ImplementationRepository::Administration *tao_impl, + const char * server, + const ::ImplementationRepository::StartupOptions & options + ACE_ENV_ARG_DECL_NOT_USED + ) + : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall), + _tao_impl (tao_impl), + server_ (server), + options_ (options) +{} + +Dynamic::ParameterList * +TAO_ServerRequestInfo_ImplementationRepository_Administration_reregister_server::arguments ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the argument list on demand. + Dynamic::ParameterList *parameter_list = + TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + Dynamic::ParameterList_var safe_parameter_list = parameter_list; + parameter_list->length (2); + CORBA::ULong len = 0; + + (*parameter_list)[len].argument <<= server_; + (*parameter_list)[len].mode = CORBA::PARAM_IN; + len++; + + (*parameter_list)[len].argument <<= this->options_; + (*parameter_list)[len].mode = CORBA::PARAM_IN; + len++; + + return safe_parameter_list._retn (); +} + +Dynamic::ExceptionList * +TAO_ServerRequestInfo_ImplementationRepository_Administration_reregister_server::exceptions ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the exception list on demand. + Dynamic::ExceptionList *exception_list = + TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + Dynamic::ExceptionList_var safe_exception_list = exception_list; + + static CORBA::TypeCode_ptr _tao_ImplementationRepository_Administration_reregister_server_exceptiondata[] = + { + ImplementationRepository::_tc_AlreadyRegistered, + ImplementationRepository::_tc_NotFound + }; + + exception_list->length (2); + for (CORBA::ULong i = 0; i < 2; ++i) + { + CORBA::TypeCode_ptr tcp = _tao_ImplementationRepository_Administration_reregister_server_exceptiondata[i]; + TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1); + (*exception_list)[i] = tcp_object; + } + + return safe_exception_list._retn (); +} + +CORBA::Any * +TAO_ServerRequestInfo_ImplementationRepository_Administration_reregister_server::result ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the result on demand. + CORBA::Boolean tk_void_any = 1; + CORBA::Any *result_any = + TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + return result_any; +} + +char * +TAO_ServerRequestInfo_ImplementationRepository_Administration_reregister_server::target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_NOT_USED + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return + CORBA::string_dup (this->_tao_impl->_interface_repository_id ()); +} + +CORBA::Boolean +TAO_ServerRequestInfo_ImplementationRepository_Administration_reregister_server::target_is_a ( + const char * id + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER); +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:74 + +class TAO_ServerRequestInfo_ImplementationRepository_Administration_remove_server : public TAO_ServerRequestInfo +{ +public: + TAO_ServerRequestInfo_ImplementationRepository_Administration_remove_server ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *tao_servant_upcall, + POA_ImplementationRepository::Administration *tao_impl, + const char * server + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + virtual Dynamic::ParameterList * arguments ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual Dynamic::ExceptionList * exceptions ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Any * result ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual char * target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Boolean target_is_a ( + const char * id + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + TAO_ServerRequestInfo_ImplementationRepository_Administration_remove_server ( + const TAO_ServerRequestInfo_ImplementationRepository_Administration_remove_server & + ); + + void operator= ( + const TAO_ServerRequestInfo_ImplementationRepository_Administration_remove_server & + ); + +private: + POA_ImplementationRepository::Administration *_tao_impl; + + const char * server_; +}; + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:438 + +TAO_ServerRequestInfo_ImplementationRepository_Administration_remove_server::TAO_ServerRequestInfo_ImplementationRepository_Administration_remove_server ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *_tao_servant_upcall, + POA_ImplementationRepository::Administration *tao_impl, + const char * server + ACE_ENV_ARG_DECL_NOT_USED + ) + : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall), + _tao_impl (tao_impl), + server_ (server) +{} + +Dynamic::ParameterList * +TAO_ServerRequestInfo_ImplementationRepository_Administration_remove_server::arguments ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the argument list on demand. + Dynamic::ParameterList *parameter_list = + TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + Dynamic::ParameterList_var safe_parameter_list = parameter_list; + parameter_list->length (1); + CORBA::ULong len = 0; + + (*parameter_list)[len].argument <<= server_; + (*parameter_list)[len].mode = CORBA::PARAM_IN; + len++; + + return safe_parameter_list._retn (); +} + +Dynamic::ExceptionList * +TAO_ServerRequestInfo_ImplementationRepository_Administration_remove_server::exceptions ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the exception list on demand. + Dynamic::ExceptionList *exception_list = + TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + Dynamic::ExceptionList_var safe_exception_list = exception_list; + + static CORBA::TypeCode_ptr _tao_ImplementationRepository_Administration_remove_server_exceptiondata[] = + { + ImplementationRepository::_tc_NotFound + }; + + exception_list->length (1); + for (CORBA::ULong i = 0; i < 1; ++i) + { + CORBA::TypeCode_ptr tcp = _tao_ImplementationRepository_Administration_remove_server_exceptiondata[i]; + TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1); + (*exception_list)[i] = tcp_object; + } + + return safe_exception_list._retn (); +} + +CORBA::Any * +TAO_ServerRequestInfo_ImplementationRepository_Administration_remove_server::result ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the result on demand. + CORBA::Boolean tk_void_any = 1; + CORBA::Any *result_any = + TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + return result_any; +} + +char * +TAO_ServerRequestInfo_ImplementationRepository_Administration_remove_server::target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_NOT_USED + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return + CORBA::string_dup (this->_tao_impl->_interface_repository_id ()); +} + +CORBA::Boolean +TAO_ServerRequestInfo_ImplementationRepository_Administration_remove_server::target_is_a ( + const char * id + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER); +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:74 + +class TAO_ServerRequestInfo_ImplementationRepository_Administration_shutdown_server : public TAO_ServerRequestInfo +{ +public: + TAO_ServerRequestInfo_ImplementationRepository_Administration_shutdown_server ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *tao_servant_upcall, + POA_ImplementationRepository::Administration *tao_impl, + const char * server + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + virtual Dynamic::ParameterList * arguments ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual Dynamic::ExceptionList * exceptions ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Any * result ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual char * target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Boolean target_is_a ( + const char * id + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + TAO_ServerRequestInfo_ImplementationRepository_Administration_shutdown_server ( + const TAO_ServerRequestInfo_ImplementationRepository_Administration_shutdown_server & + ); + + void operator= ( + const TAO_ServerRequestInfo_ImplementationRepository_Administration_shutdown_server & + ); + +private: + POA_ImplementationRepository::Administration *_tao_impl; + + const char * server_; +}; + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:438 + +TAO_ServerRequestInfo_ImplementationRepository_Administration_shutdown_server::TAO_ServerRequestInfo_ImplementationRepository_Administration_shutdown_server ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *_tao_servant_upcall, + POA_ImplementationRepository::Administration *tao_impl, + const char * server + ACE_ENV_ARG_DECL_NOT_USED + ) + : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall), + _tao_impl (tao_impl), + server_ (server) +{} + +Dynamic::ParameterList * +TAO_ServerRequestInfo_ImplementationRepository_Administration_shutdown_server::arguments ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the argument list on demand. + Dynamic::ParameterList *parameter_list = + TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + Dynamic::ParameterList_var safe_parameter_list = parameter_list; + parameter_list->length (1); + CORBA::ULong len = 0; + + (*parameter_list)[len].argument <<= server_; + (*parameter_list)[len].mode = CORBA::PARAM_IN; + len++; + + return safe_parameter_list._retn (); +} + +Dynamic::ExceptionList * +TAO_ServerRequestInfo_ImplementationRepository_Administration_shutdown_server::exceptions ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the exception list on demand. + Dynamic::ExceptionList *exception_list = + TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + Dynamic::ExceptionList_var safe_exception_list = exception_list; + + static CORBA::TypeCode_ptr _tao_ImplementationRepository_Administration_shutdown_server_exceptiondata[] = + { + ImplementationRepository::_tc_NotFound + }; + + exception_list->length (1); + for (CORBA::ULong i = 0; i < 1; ++i) + { + CORBA::TypeCode_ptr tcp = _tao_ImplementationRepository_Administration_shutdown_server_exceptiondata[i]; + TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1); + (*exception_list)[i] = tcp_object; + } + + return safe_exception_list._retn (); +} + +CORBA::Any * +TAO_ServerRequestInfo_ImplementationRepository_Administration_shutdown_server::result ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the result on demand. + CORBA::Boolean tk_void_any = 1; + CORBA::Any *result_any = + TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + return result_any; +} + +char * +TAO_ServerRequestInfo_ImplementationRepository_Administration_shutdown_server::target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_NOT_USED + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return + CORBA::string_dup (this->_tao_impl->_interface_repository_id ()); +} + +CORBA::Boolean +TAO_ServerRequestInfo_ImplementationRepository_Administration_shutdown_server::target_is_a ( + const char * id + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER); +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:74 + +class TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_running : public TAO_ServerRequestInfo +{ +public: + TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_running ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *tao_servant_upcall, + POA_ImplementationRepository::Administration *tao_impl, + const char * server, + const char * partial_ior, + ::ImplementationRepository::ServerObject_ptr server_object + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + virtual Dynamic::ParameterList * arguments ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual Dynamic::ExceptionList * exceptions ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Any * result ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual char * target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Boolean target_is_a ( + const char * id + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_running ( + const TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_running & + ); + + void operator= ( + const TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_running & + ); + +private: + POA_ImplementationRepository::Administration *_tao_impl; + + const char * server_; + const char * partial_ior_; + ::ImplementationRepository::ServerObject_ptr server_object_; +}; + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:438 + +TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_running::TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_running ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *_tao_servant_upcall, + POA_ImplementationRepository::Administration *tao_impl, + const char * server, + const char * partial_ior, + ::ImplementationRepository::ServerObject_ptr server_object + ACE_ENV_ARG_DECL_NOT_USED + ) + : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall), + _tao_impl (tao_impl), + server_ (server), + partial_ior_ (partial_ior), + server_object_ (server_object) +{} + +Dynamic::ParameterList * +TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_running::arguments ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the argument list on demand. + Dynamic::ParameterList *parameter_list = + TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + Dynamic::ParameterList_var safe_parameter_list = parameter_list; + parameter_list->length (3); + CORBA::ULong len = 0; + + (*parameter_list)[len].argument <<= server_; + (*parameter_list)[len].mode = CORBA::PARAM_IN; + len++; + + (*parameter_list)[len].argument <<= partial_ior_; + (*parameter_list)[len].mode = CORBA::PARAM_IN; + len++; + + (*parameter_list)[len].argument <<= this->server_object_; + (*parameter_list)[len].mode = CORBA::PARAM_IN; + len++; + + return safe_parameter_list._retn (); +} + +Dynamic::ExceptionList * +TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_running::exceptions ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the exception list on demand. + Dynamic::ExceptionList *exception_list = + TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + Dynamic::ExceptionList_var safe_exception_list = exception_list; + + static CORBA::TypeCode_ptr _tao_ImplementationRepository_Administration_server_is_running_exceptiondata[] = + { + ImplementationRepository::_tc_NotFound + }; + + exception_list->length (1); + for (CORBA::ULong i = 0; i < 1; ++i) + { + CORBA::TypeCode_ptr tcp = _tao_ImplementationRepository_Administration_server_is_running_exceptiondata[i]; + TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1); + (*exception_list)[i] = tcp_object; + } + + return safe_exception_list._retn (); +} + +CORBA::Any * +TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_running::result ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the result on demand. + CORBA::Boolean tk_void_any = 1; + CORBA::Any *result_any = + TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + return result_any; +} + +char * +TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_running::target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_NOT_USED + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return + CORBA::string_dup (this->_tao_impl->_interface_repository_id ()); +} + +CORBA::Boolean +TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_running::target_is_a ( + const char * id + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER); +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:74 + +class TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_shutting_down : public TAO_ServerRequestInfo +{ +public: + TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_shutting_down ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *tao_servant_upcall, + POA_ImplementationRepository::Administration *tao_impl, + const char * server + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + virtual Dynamic::ParameterList * arguments ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual Dynamic::ExceptionList * exceptions ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Any * result ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual char * target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Boolean target_is_a ( + const char * id + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_shutting_down ( + const TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_shutting_down & + ); + + void operator= ( + const TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_shutting_down & + ); + +private: + POA_ImplementationRepository::Administration *_tao_impl; + + const char * server_; +}; + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:438 + +TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_shutting_down::TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_shutting_down ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *_tao_servant_upcall, + POA_ImplementationRepository::Administration *tao_impl, + const char * server + ACE_ENV_ARG_DECL_NOT_USED + ) + : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall), + _tao_impl (tao_impl), + server_ (server) +{} + +Dynamic::ParameterList * +TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_shutting_down::arguments ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the argument list on demand. + Dynamic::ParameterList *parameter_list = + TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + Dynamic::ParameterList_var safe_parameter_list = parameter_list; + parameter_list->length (1); + CORBA::ULong len = 0; + + (*parameter_list)[len].argument <<= server_; + (*parameter_list)[len].mode = CORBA::PARAM_IN; + len++; + + return safe_parameter_list._retn (); +} + +Dynamic::ExceptionList * +TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_shutting_down::exceptions ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the exception list on demand. + Dynamic::ExceptionList *exception_list = + TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + Dynamic::ExceptionList_var safe_exception_list = exception_list; + + static CORBA::TypeCode_ptr _tao_ImplementationRepository_Administration_server_is_shutting_down_exceptiondata[] = + { + ImplementationRepository::_tc_NotFound + }; + + exception_list->length (1); + for (CORBA::ULong i = 0; i < 1; ++i) + { + CORBA::TypeCode_ptr tcp = _tao_ImplementationRepository_Administration_server_is_shutting_down_exceptiondata[i]; + TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1); + (*exception_list)[i] = tcp_object; + } + + return safe_exception_list._retn (); +} + +CORBA::Any * +TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_shutting_down::result ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the result on demand. + CORBA::Boolean tk_void_any = 1; + CORBA::Any *result_any = + TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + return result_any; +} + +char * +TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_shutting_down::target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_NOT_USED + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return + CORBA::string_dup (this->_tao_impl->_interface_repository_id ()); +} + +CORBA::Boolean +TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_shutting_down::target_is_a ( + const char * id + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER); +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:74 + +class TAO_ServerRequestInfo_ImplementationRepository_Administration_find : public TAO_ServerRequestInfo +{ +public: + TAO_ServerRequestInfo_ImplementationRepository_Administration_find ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *tao_servant_upcall, + POA_ImplementationRepository::Administration *tao_impl, + const char * server + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + virtual Dynamic::ParameterList * arguments ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual Dynamic::ExceptionList * exceptions ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Any * result ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual char * target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Boolean target_is_a ( + const char * id + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + TAO_ServerRequestInfo_ImplementationRepository_Administration_find ( + const TAO_ServerRequestInfo_ImplementationRepository_Administration_find & + ); + + void operator= ( + const TAO_ServerRequestInfo_ImplementationRepository_Administration_find & + ); + +private: + POA_ImplementationRepository::Administration *_tao_impl; + + const char * server_; +}; + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:438 + +TAO_ServerRequestInfo_ImplementationRepository_Administration_find::TAO_ServerRequestInfo_ImplementationRepository_Administration_find ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *_tao_servant_upcall, + POA_ImplementationRepository::Administration *tao_impl, + const char * server + ACE_ENV_ARG_DECL_NOT_USED + ) + : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall), + _tao_impl (tao_impl), + server_ (server) +{} + +Dynamic::ParameterList * +TAO_ServerRequestInfo_ImplementationRepository_Administration_find::arguments ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the argument list on demand. + Dynamic::ParameterList *parameter_list = + TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + Dynamic::ParameterList_var safe_parameter_list = parameter_list; + parameter_list->length (1); + CORBA::ULong len = 0; + + (*parameter_list)[len].argument <<= server_; + (*parameter_list)[len].mode = CORBA::PARAM_IN; + len++; + + return safe_parameter_list._retn (); +} + +Dynamic::ExceptionList * +TAO_ServerRequestInfo_ImplementationRepository_Administration_find::exceptions ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the exception list on demand. + Dynamic::ExceptionList *exception_list = + TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + Dynamic::ExceptionList_var safe_exception_list = exception_list; + + static CORBA::TypeCode_ptr _tao_ImplementationRepository_Administration_find_exceptiondata[] = + { + ImplementationRepository::_tc_NotFound + }; + + exception_list->length (1); + for (CORBA::ULong i = 0; i < 1; ++i) + { + CORBA::TypeCode_ptr tcp = _tao_ImplementationRepository_Administration_find_exceptiondata[i]; + TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1); + (*exception_list)[i] = tcp_object; + } + + return safe_exception_list._retn (); +} + +CORBA::Any * +TAO_ServerRequestInfo_ImplementationRepository_Administration_find::result ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the result on demand. + CORBA::Boolean tk_void_any = 1; + CORBA::Any *result_any = + TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + return result_any; +} + +char * +TAO_ServerRequestInfo_ImplementationRepository_Administration_find::target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_NOT_USED + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return + CORBA::string_dup (this->_tao_impl->_interface_repository_id ()); +} + +CORBA::Boolean +TAO_ServerRequestInfo_ImplementationRepository_Administration_find::target_is_a ( + const char * id + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER); +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:74 + +class TAO_ServerRequestInfo_ImplementationRepository_Administration_list : public TAO_ServerRequestInfo +{ +public: + TAO_ServerRequestInfo_ImplementationRepository_Administration_list ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *tao_servant_upcall, + POA_ImplementationRepository::Administration *tao_impl, + const ::CORBA::ULong & how_many + + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + virtual Dynamic::ParameterList * arguments ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual Dynamic::ExceptionList * exceptions ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Any * result ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual char * target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Boolean target_is_a ( + const char * id + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + TAO_ServerRequestInfo_ImplementationRepository_Administration_list ( + const TAO_ServerRequestInfo_ImplementationRepository_Administration_list & + ); + + void operator= ( + const TAO_ServerRequestInfo_ImplementationRepository_Administration_list & + ); + +private: + POA_ImplementationRepository::Administration *_tao_impl; + + const ::CORBA::ULong & how_many_; + +}; + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:438 + +TAO_ServerRequestInfo_ImplementationRepository_Administration_list::TAO_ServerRequestInfo_ImplementationRepository_Administration_list ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *_tao_servant_upcall, + POA_ImplementationRepository::Administration *tao_impl, + const ::CORBA::ULong & how_many + + ACE_ENV_ARG_DECL_NOT_USED + ) + : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall), + _tao_impl (tao_impl), + how_many_ (how_many) + +{} + +Dynamic::ParameterList * +TAO_ServerRequestInfo_ImplementationRepository_Administration_list::arguments ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the argument list on demand. + Dynamic::ParameterList *parameter_list = + TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + Dynamic::ParameterList_var safe_parameter_list = parameter_list; + parameter_list->length (1); + CORBA::ULong len = 0; + + (*parameter_list)[len].argument <<= how_many_; + (*parameter_list)[len].mode = CORBA::PARAM_IN; + len++; + + + return safe_parameter_list._retn (); +} + +Dynamic::ExceptionList * +TAO_ServerRequestInfo_ImplementationRepository_Administration_list::exceptions ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the exception list on demand. + Dynamic::ExceptionList *exception_list = + TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + return exception_list; +} + +CORBA::Any * +TAO_ServerRequestInfo_ImplementationRepository_Administration_list::result ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the result on demand. + CORBA::Boolean tk_void_any = 1; + CORBA::Any *result_any = + TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + return result_any; +} + +char * +TAO_ServerRequestInfo_ImplementationRepository_Administration_list::target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_NOT_USED + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return + CORBA::string_dup (this->_tao_impl->_interface_repository_id ()); +} + +CORBA::Boolean +TAO_ServerRequestInfo_ImplementationRepository_Administration_list::target_is_a ( + const char * id + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER); +} + +#endif /* TAO_HAS_INTERCEPTORS */ + +/////////////////////////////////////////////////////////////////////// +// Strategized Proxy Broker Implementation +// + +// TAO_IDL - Generated from +// be\be_visitor_interface/strategized_proxy_broker_ss.cpp:40 + +// Factory function Implementation. +POA_ImplementationRepository::_TAO_Administration_Strategized_Proxy_Broker * +POA_ImplementationRepository::_TAO_Administration_Strategized_Proxy_Broker::the_TAO_Administration_Strategized_Proxy_Broker (void) +{ + static POA_ImplementationRepository::_TAO_Administration_Strategized_Proxy_Broker + strategized_proxy_broker; + + return &strategized_proxy_broker; +} + +POA_ImplementationRepository::_TAO_Administration_Strategized_Proxy_Broker::_TAO_Administration_Strategized_Proxy_Broker (void) +{ +} + +POA_ImplementationRepository::_TAO_Administration_Strategized_Proxy_Broker::~_TAO_Administration_Strategized_Proxy_Broker (void) +{ +} + +TAO::Collocation_Strategy +POA_ImplementationRepository::_TAO_Administration_Strategized_Proxy_Broker::get_strategy ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + TAO::Collocation_Strategy strategy = + TAO_ORB_Core::collocation_strategy (obj ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (TAO::TAO_CS_REMOTE_STRATEGY); + + return strategy; +} + +void +POA_ImplementationRepository::_TAO_Administration_Strategized_Proxy_Broker::dispatch ( + CORBA::Object_ptr obj, + CORBA::Object_out forward_obj, + TAO::Argument ** args, + int num_args, + const char * op, + size_t op_len, + TAO::Collocation_Strategy strategy + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::Exception)) +{ + TAO::Portable_Server::Servant_Upcall servant_upcall ( + obj->_stubobj ()->servant_orb_var ()->orb_core () + ); + + TAO_Collocated_Skeleton collocated_skel; + TAO_Abstract_ServantBase *servant = 0; + + if (strategy == TAO::TAO_CS_THRU_POA_STRATEGY) + { + servant_upcall.prepare_for_upcall ( + obj->_stubobj ()->object_key (), + op, + forward_obj + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; + + servant_upcall.pre_invoke_collocated_request ( + ACE_ENV_SINGLE_ARG_PARAMETER + ); + ACE_CHECK; + + servant = servant_upcall.servant (); + } + else + { + servant = obj->_servant (); + } + + int status = servant->_find (op, + collocated_skel, + strategy, + op_len); + + if (status == -1) + { + ACE_THROW (CORBA::BAD_OPERATION (TAO::VMCID | 2, CORBA::COMPLETED_NO)); + } + + ACE_TRY + { + collocated_skel (servant, + args, + num_args + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } +#if (TAO_HAS_MINIMUM_CORBA == 0) + ACE_CATCH (PortableServer::ForwardRequest, forward_request) + { + forward_obj = + CORBA::Object::_duplicate (forward_request.forward_reference.in ()); + return; + } +#else + ACE_CATCHANY + { + ACE_UNUSED_ARG (forward_obj); + ACE_RE_THROW; + } +#endif /* TAO_HAS_MINIMUM_CORBA */ + ACE_ENDTRY; + ACE_CHECK; +} + +// +// End Strategized Proxy Broker Implementation +/////////////////////////////////////////////////////////////////////// + +// TAO_IDL - Generated from +// be\be_visitor_interface/interface_ss.cpp:640 + +TAO::Collocation_Proxy_Broker * +ImplementationRepository__TAO_Administration_Proxy_Broker_Factory_function (CORBA::Object_ptr) +{ + return + ::POA_ImplementationRepository::_TAO_Administration_Strategized_Proxy_Broker::the_TAO_Administration_Strategized_Proxy_Broker (); +} + +int +ImplementationRepository__TAO_Administration_Proxy_Broker_Factory_Initializer (size_t) +{ + ImplementationRepository__TAO_Administration_Proxy_Broker_Factory_function_pointer = + ImplementationRepository__TAO_Administration_Proxy_Broker_Factory_function; + + return 0; +} + +static int +ImplementationRepository__TAO_Administration_Proxy_Broker_Stub_Factory_Initializer_Scarecrow = + ImplementationRepository__TAO_Administration_Proxy_Broker_Factory_Initializer ( + reinterpret_cast< + size_t> ( + ImplementationRepository__TAO_Administration_Proxy_Broker_Factory_Initializer + ) + ); + + +/////////////////////////////////////////////////////////////////////// +// ThruPOA Proxy Implementation +// + +// TAO_IDL - Generated from +// be\be_visitor_interface/thru_poa_proxy_impl_ss.cpp:37 + +POA_ImplementationRepository::_TAO_Administration_ThruPOA_Proxy_Impl::_TAO_Administration_ThruPOA_Proxy_Impl (void) +{} + +// ThruPOA Implementation of the IDL interface methods + +// TAO_IDL - Generated from +// be\be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52 + +void +POA_ImplementationRepository::_TAO_Administration_ThruPOA_Proxy_Impl::activate_server ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound, + ::ImplementationRepository::CannotActivate + )) +{ + reinterpret_cast< + POA_ImplementationRepository::Administration_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/Administration:1.0" + ) + )->activate_server ( + ((TAO::Arg_Traits< CORBA::Char *>::in_arg_val *) args[1])->arg () + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52 + +void +POA_ImplementationRepository::_TAO_Administration_ThruPOA_Proxy_Impl::register_server ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::AlreadyRegistered, + ::ImplementationRepository::NotFound + )) +{ + reinterpret_cast< + POA_ImplementationRepository::Administration_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/Administration:1.0" + ) + )->register_server ( + ((TAO::Arg_Traits< CORBA::Char *>::in_arg_val *) args[1])->arg (), + ((TAO::Arg_Traits< ImplementationRepository::StartupOptions>::in_arg_val *) args[2])->arg () + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52 + +void +POA_ImplementationRepository::_TAO_Administration_ThruPOA_Proxy_Impl::reregister_server ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::AlreadyRegistered, + ::ImplementationRepository::NotFound + )) +{ + reinterpret_cast< + POA_ImplementationRepository::Administration_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/Administration:1.0" + ) + )->reregister_server ( + ((TAO::Arg_Traits< CORBA::Char *>::in_arg_val *) args[1])->arg (), + ((TAO::Arg_Traits< ImplementationRepository::StartupOptions>::in_arg_val *) args[2])->arg () + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52 + +void +POA_ImplementationRepository::_TAO_Administration_ThruPOA_Proxy_Impl::remove_server ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )) +{ + reinterpret_cast< + POA_ImplementationRepository::Administration_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/Administration:1.0" + ) + )->remove_server ( + ((TAO::Arg_Traits< CORBA::Char *>::in_arg_val *) args[1])->arg () + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52 + +void +POA_ImplementationRepository::_TAO_Administration_ThruPOA_Proxy_Impl::shutdown_server ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )) +{ + reinterpret_cast< + POA_ImplementationRepository::Administration_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/Administration:1.0" + ) + )->shutdown_server ( + ((TAO::Arg_Traits< CORBA::Char *>::in_arg_val *) args[1])->arg () + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52 + +void +POA_ImplementationRepository::_TAO_Administration_ThruPOA_Proxy_Impl::server_is_running ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )) +{ + reinterpret_cast< + POA_ImplementationRepository::Administration_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/Administration:1.0" + ) + )->server_is_running ( + ((TAO::Arg_Traits< CORBA::Char *>::in_arg_val *) args[1])->arg (), + ((TAO::Arg_Traits< CORBA::Char *>::in_arg_val *) args[2])->arg (), + ((TAO::Arg_Traits< ImplementationRepository::ServerObject>::in_arg_val *) args[3])->arg () + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52 + +void +POA_ImplementationRepository::_TAO_Administration_ThruPOA_Proxy_Impl::server_is_shutting_down ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )) +{ + reinterpret_cast< + POA_ImplementationRepository::Administration_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/Administration:1.0" + ) + )->server_is_shutting_down ( + ((TAO::Arg_Traits< CORBA::Char *>::in_arg_val *) args[1])->arg () + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52 + +void +POA_ImplementationRepository::_TAO_Administration_ThruPOA_Proxy_Impl::find ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )) +{ + reinterpret_cast< + POA_ImplementationRepository::Administration_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/Administration:1.0" + ) + )->find ( + ((TAO::Arg_Traits< CORBA::Char *>::in_arg_val *) args[1])->arg (), + ((TAO::Arg_Traits< ImplementationRepository::ServerInformation>::out_arg_val *) args[2])->arg () + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52 + +void +POA_ImplementationRepository::_TAO_Administration_ThruPOA_Proxy_Impl::list ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + reinterpret_cast< + POA_ImplementationRepository::Administration_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/Administration:1.0" + ) + )->list ( + ((TAO::Arg_Traits< ::CORBA::ULong>::in_arg_val *) args[1])->arg (), + ((TAO::Arg_Traits< ImplementationRepository::ServerInformationList>::out_arg_val *) args[2])->arg (), + ((TAO::Arg_Traits< ImplementationRepository::ServerInformationIterator>::out_arg_val *) args[3])->arg () + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +} + +// +// End ThruPOA Proxy Implementation +/////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////// +// Direct Proxy Implementation +// + +POA_ImplementationRepository::_TAO_Administration_Direct_Proxy_Impl::_TAO_Administration_Direct_Proxy_Impl (void) +{} + +// TAO_IDL - Generated from +// be\be_visitor_operation/direct_proxy_impl_ss.cpp:42 + +void +POA_ImplementationRepository::_TAO_Administration_Direct_Proxy_Impl::activate_server ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound, + ::ImplementationRepository::CannotActivate + )) +{ + reinterpret_cast< + POA_ImplementationRepository::Administration_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/Administration:1.0" + ) + )->activate_server ( + ((TAO::Arg_Traits< CORBA::Char *>::in_arg_val *) args[1])->arg () + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +}// TAO_IDL - Generated from +// be\be_visitor_operation/direct_proxy_impl_ss.cpp:42 + +void +POA_ImplementationRepository::_TAO_Administration_Direct_Proxy_Impl::register_server ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::AlreadyRegistered, + ::ImplementationRepository::NotFound + )) +{ + reinterpret_cast< + POA_ImplementationRepository::Administration_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/Administration:1.0" + ) + )->register_server ( + ((TAO::Arg_Traits< CORBA::Char *>::in_arg_val *) args[1])->arg (), + ((TAO::Arg_Traits< ImplementationRepository::StartupOptions>::in_arg_val *) args[2])->arg () + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +}// TAO_IDL - Generated from +// be\be_visitor_operation/direct_proxy_impl_ss.cpp:42 + +void +POA_ImplementationRepository::_TAO_Administration_Direct_Proxy_Impl::reregister_server ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::AlreadyRegistered, + ::ImplementationRepository::NotFound + )) +{ + reinterpret_cast< + POA_ImplementationRepository::Administration_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/Administration:1.0" + ) + )->reregister_server ( + ((TAO::Arg_Traits< CORBA::Char *>::in_arg_val *) args[1])->arg (), + ((TAO::Arg_Traits< ImplementationRepository::StartupOptions>::in_arg_val *) args[2])->arg () + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +}// TAO_IDL - Generated from +// be\be_visitor_operation/direct_proxy_impl_ss.cpp:42 + +void +POA_ImplementationRepository::_TAO_Administration_Direct_Proxy_Impl::remove_server ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )) +{ + reinterpret_cast< + POA_ImplementationRepository::Administration_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/Administration:1.0" + ) + )->remove_server ( + ((TAO::Arg_Traits< CORBA::Char *>::in_arg_val *) args[1])->arg () + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +}// TAO_IDL - Generated from +// be\be_visitor_operation/direct_proxy_impl_ss.cpp:42 + +void +POA_ImplementationRepository::_TAO_Administration_Direct_Proxy_Impl::shutdown_server ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )) +{ + reinterpret_cast< + POA_ImplementationRepository::Administration_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/Administration:1.0" + ) + )->shutdown_server ( + ((TAO::Arg_Traits< CORBA::Char *>::in_arg_val *) args[1])->arg () + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +}// TAO_IDL - Generated from +// be\be_visitor_operation/direct_proxy_impl_ss.cpp:42 + +void +POA_ImplementationRepository::_TAO_Administration_Direct_Proxy_Impl::server_is_running ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )) +{ + reinterpret_cast< + POA_ImplementationRepository::Administration_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/Administration:1.0" + ) + )->server_is_running ( + ((TAO::Arg_Traits< CORBA::Char *>::in_arg_val *) args[1])->arg (), + ((TAO::Arg_Traits< CORBA::Char *>::in_arg_val *) args[2])->arg (), + ((TAO::Arg_Traits< ImplementationRepository::ServerObject>::in_arg_val *) args[3])->arg () + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +}// TAO_IDL - Generated from +// be\be_visitor_operation/direct_proxy_impl_ss.cpp:42 + +void +POA_ImplementationRepository::_TAO_Administration_Direct_Proxy_Impl::server_is_shutting_down ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )) +{ + reinterpret_cast< + POA_ImplementationRepository::Administration_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/Administration:1.0" + ) + )->server_is_shutting_down ( + ((TAO::Arg_Traits< CORBA::Char *>::in_arg_val *) args[1])->arg () + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +}// TAO_IDL - Generated from +// be\be_visitor_operation/direct_proxy_impl_ss.cpp:42 + +void +POA_ImplementationRepository::_TAO_Administration_Direct_Proxy_Impl::find ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )) +{ + reinterpret_cast< + POA_ImplementationRepository::Administration_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/Administration:1.0" + ) + )->find ( + ((TAO::Arg_Traits< CORBA::Char *>::in_arg_val *) args[1])->arg (), + ((TAO::Arg_Traits< ImplementationRepository::ServerInformation>::out_arg_val *) args[2])->arg () + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +}// TAO_IDL - Generated from +// be\be_visitor_operation/direct_proxy_impl_ss.cpp:42 + +void +POA_ImplementationRepository::_TAO_Administration_Direct_Proxy_Impl::list ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + reinterpret_cast< + POA_ImplementationRepository::Administration_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/Administration:1.0" + ) + )->list ( + ((TAO::Arg_Traits< ::CORBA::ULong>::in_arg_val *) args[1])->arg (), + ((TAO::Arg_Traits< ImplementationRepository::ServerInformationList>::out_arg_val *) args[2])->arg (), + ((TAO::Arg_Traits< ImplementationRepository::ServerInformationIterator>::out_arg_val *) args[3])->arg () + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; +} + +// +// End Direct Proxy Implementation +/////////////////////////////////////////////////////////////////////// + +// TAO_IDL - Generated from +// be\be_visitor_interface/interface_ss.cpp:97 + +POA_ImplementationRepository::Administration::Administration (void) +{ + this->optable_ = &tao_ImplementationRepository_Administration_optable; +} + +POA_ImplementationRepository::Administration::Administration (const Administration& rhs) + : TAO_Abstract_ServantBase (rhs), + TAO_ServantBase (rhs) +{ +} + +POA_ImplementationRepository::Administration::~Administration (void) +{ +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_ss.cpp:98 + +void POA_ImplementationRepository::Administration::activate_server_skel ( + TAO_ServerRequest &_tao_server_request, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_ImplementationRepository::Administration *_tao_impl = + static_cast< + POA_ImplementationRepository::Administration *> ( + _tao_servant + ); + _tao_server_request.argument_flag (0); + + ::CORBA::String_var server; + + if (!( + (_tao_in >> server.out ()) + )) + { + TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + +#if (TAO_HAS_INTERCEPTORS == 1) + TAO::Portable_Server::Servant_Upcall *_tao_upcall = + static_cast< + TAO::Portable_Server::Servant_Upcall *> ( + _tao_servant_upcall + ); + + TAO_ServerRequestInterceptor_Adapter _tao_vfr ( + _tao_server_request.orb_core ()->server_request_interceptors (), + _tao_server_request.interceptor_count () + ); + + TAO_ServerRequestInfo_ImplementationRepository_Administration_activate_server _tao_ri ( + _tao_server_request, + _tao_upcall, + _tao_impl, + + server.in () + ACE_ENV_ARG_PARAMETER + ); + + ACE_TRY + { + { + TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (), + true /* Copy TSC to RSC */); + + _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (!_tao_vfr.location_forwarded ()) + { +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_impl->activate_server ( + server.in () + ACE_ENV_ARG_PARAMETER + ); + TAO_INTERCEPTOR_CHECK; +#if (TAO_HAS_INTERCEPTORS == 1) + } + } + + if (!_tao_vfr.location_forwarded ()) + { + _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL); + _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + } + ACE_CATCHANY + { + _tao_ri.exception (&ACE_ANY_EXCEPTION); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION + || _tao_status == PortableInterceptor::USER_EXCEPTION) + { + ACE_RE_THROW; + } + } + +# if defined (ACE_HAS_EXCEPTIONS) \ + && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS) + ACE_CATCHALL + { + CORBA::UNKNOWN ex; + + _tao_ri.exception (&ex); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION) + ACE_TRY_THROW (ex); + } +# endif /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */ + ACE_ENDTRY; + ACE_CHECK; +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_server_request.init_reply (); + + // In case _tao_servant_upcall is not used in this function + ACE_UNUSED_ARG (_tao_servant_upcall); +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_ss.cpp:98 + +void POA_ImplementationRepository::Administration::register_server_skel ( + TAO_ServerRequest &_tao_server_request, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_ImplementationRepository::Administration *_tao_impl = + static_cast< + POA_ImplementationRepository::Administration *> ( + _tao_servant + ); + _tao_server_request.argument_flag (0); + + ::CORBA::String_var server; + ::ImplementationRepository::StartupOptions options; + + if (!( + (_tao_in >> server.out ()) && + (_tao_in >> options) + )) + { + TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + +#if (TAO_HAS_INTERCEPTORS == 1) + TAO::Portable_Server::Servant_Upcall *_tao_upcall = + static_cast< + TAO::Portable_Server::Servant_Upcall *> ( + _tao_servant_upcall + ); + + TAO_ServerRequestInterceptor_Adapter _tao_vfr ( + _tao_server_request.orb_core ()->server_request_interceptors (), + _tao_server_request.interceptor_count () + ); + + TAO_ServerRequestInfo_ImplementationRepository_Administration_register_server _tao_ri ( + _tao_server_request, + _tao_upcall, + _tao_impl, + + server.in (), + + options + ACE_ENV_ARG_PARAMETER + ); + + ACE_TRY + { + { + TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (), + true /* Copy TSC to RSC */); + + _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (!_tao_vfr.location_forwarded ()) + { +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_impl->register_server ( + server.in (), + + options + ACE_ENV_ARG_PARAMETER + ); + TAO_INTERCEPTOR_CHECK; +#if (TAO_HAS_INTERCEPTORS == 1) + } + } + + if (!_tao_vfr.location_forwarded ()) + { + _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL); + _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + } + ACE_CATCHANY + { + _tao_ri.exception (&ACE_ANY_EXCEPTION); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION + || _tao_status == PortableInterceptor::USER_EXCEPTION) + { + ACE_RE_THROW; + } + } + +# if defined (ACE_HAS_EXCEPTIONS) \ + && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS) + ACE_CATCHALL + { + CORBA::UNKNOWN ex; + + _tao_ri.exception (&ex); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION) + ACE_TRY_THROW (ex); + } +# endif /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */ + ACE_ENDTRY; + ACE_CHECK; +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_server_request.init_reply (); + + // In case _tao_servant_upcall is not used in this function + ACE_UNUSED_ARG (_tao_servant_upcall); +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_ss.cpp:98 + +void POA_ImplementationRepository::Administration::reregister_server_skel ( + TAO_ServerRequest &_tao_server_request, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_ImplementationRepository::Administration *_tao_impl = + static_cast< + POA_ImplementationRepository::Administration *> ( + _tao_servant + ); + _tao_server_request.argument_flag (0); + + ::CORBA::String_var server; + ::ImplementationRepository::StartupOptions options; + + if (!( + (_tao_in >> server.out ()) && + (_tao_in >> options) + )) + { + TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + +#if (TAO_HAS_INTERCEPTORS == 1) + TAO::Portable_Server::Servant_Upcall *_tao_upcall = + static_cast< + TAO::Portable_Server::Servant_Upcall *> ( + _tao_servant_upcall + ); + + TAO_ServerRequestInterceptor_Adapter _tao_vfr ( + _tao_server_request.orb_core ()->server_request_interceptors (), + _tao_server_request.interceptor_count () + ); + + TAO_ServerRequestInfo_ImplementationRepository_Administration_reregister_server _tao_ri ( + _tao_server_request, + _tao_upcall, + _tao_impl, + + server.in (), + + options + ACE_ENV_ARG_PARAMETER + ); + + ACE_TRY + { + { + TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (), + true /* Copy TSC to RSC */); + + _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (!_tao_vfr.location_forwarded ()) + { +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_impl->reregister_server ( + server.in (), + + options + ACE_ENV_ARG_PARAMETER + ); + TAO_INTERCEPTOR_CHECK; +#if (TAO_HAS_INTERCEPTORS == 1) + } + } + + if (!_tao_vfr.location_forwarded ()) + { + _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL); + _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + } + ACE_CATCHANY + { + _tao_ri.exception (&ACE_ANY_EXCEPTION); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION + || _tao_status == PortableInterceptor::USER_EXCEPTION) + { + ACE_RE_THROW; + } + } + +# if defined (ACE_HAS_EXCEPTIONS) \ + && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS) + ACE_CATCHALL + { + CORBA::UNKNOWN ex; + + _tao_ri.exception (&ex); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION) + ACE_TRY_THROW (ex); + } +# endif /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */ + ACE_ENDTRY; + ACE_CHECK; +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_server_request.init_reply (); + + // In case _tao_servant_upcall is not used in this function + ACE_UNUSED_ARG (_tao_servant_upcall); +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_ss.cpp:98 + +void POA_ImplementationRepository::Administration::remove_server_skel ( + TAO_ServerRequest &_tao_server_request, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_ImplementationRepository::Administration *_tao_impl = + static_cast< + POA_ImplementationRepository::Administration *> ( + _tao_servant + ); + _tao_server_request.argument_flag (0); + + ::CORBA::String_var server; + + if (!( + (_tao_in >> server.out ()) + )) + { + TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + +#if (TAO_HAS_INTERCEPTORS == 1) + TAO::Portable_Server::Servant_Upcall *_tao_upcall = + static_cast< + TAO::Portable_Server::Servant_Upcall *> ( + _tao_servant_upcall + ); + + TAO_ServerRequestInterceptor_Adapter _tao_vfr ( + _tao_server_request.orb_core ()->server_request_interceptors (), + _tao_server_request.interceptor_count () + ); + + TAO_ServerRequestInfo_ImplementationRepository_Administration_remove_server _tao_ri ( + _tao_server_request, + _tao_upcall, + _tao_impl, + + server.in () + ACE_ENV_ARG_PARAMETER + ); + + ACE_TRY + { + { + TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (), + true /* Copy TSC to RSC */); + + _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (!_tao_vfr.location_forwarded ()) + { +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_impl->remove_server ( + server.in () + ACE_ENV_ARG_PARAMETER + ); + TAO_INTERCEPTOR_CHECK; +#if (TAO_HAS_INTERCEPTORS == 1) + } + } + + if (!_tao_vfr.location_forwarded ()) + { + _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL); + _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + } + ACE_CATCHANY + { + _tao_ri.exception (&ACE_ANY_EXCEPTION); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION + || _tao_status == PortableInterceptor::USER_EXCEPTION) + { + ACE_RE_THROW; + } + } + +# if defined (ACE_HAS_EXCEPTIONS) \ + && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS) + ACE_CATCHALL + { + CORBA::UNKNOWN ex; + + _tao_ri.exception (&ex); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION) + ACE_TRY_THROW (ex); + } +# endif /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */ + ACE_ENDTRY; + ACE_CHECK; +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_server_request.init_reply (); + + // In case _tao_servant_upcall is not used in this function + ACE_UNUSED_ARG (_tao_servant_upcall); +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_ss.cpp:98 + +void POA_ImplementationRepository::Administration::shutdown_server_skel ( + TAO_ServerRequest &_tao_server_request, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_ImplementationRepository::Administration *_tao_impl = + static_cast< + POA_ImplementationRepository::Administration *> ( + _tao_servant + ); + _tao_server_request.argument_flag (0); + + ::CORBA::String_var server; + + if (!( + (_tao_in >> server.out ()) + )) + { + TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + +#if (TAO_HAS_INTERCEPTORS == 1) + TAO::Portable_Server::Servant_Upcall *_tao_upcall = + static_cast< + TAO::Portable_Server::Servant_Upcall *> ( + _tao_servant_upcall + ); + + TAO_ServerRequestInterceptor_Adapter _tao_vfr ( + _tao_server_request.orb_core ()->server_request_interceptors (), + _tao_server_request.interceptor_count () + ); + + TAO_ServerRequestInfo_ImplementationRepository_Administration_shutdown_server _tao_ri ( + _tao_server_request, + _tao_upcall, + _tao_impl, + + server.in () + ACE_ENV_ARG_PARAMETER + ); + + ACE_TRY + { + { + TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (), + true /* Copy TSC to RSC */); + + _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (!_tao_vfr.location_forwarded ()) + { +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_impl->shutdown_server ( + server.in () + ACE_ENV_ARG_PARAMETER + ); + TAO_INTERCEPTOR_CHECK; +#if (TAO_HAS_INTERCEPTORS == 1) + } + } + + if (!_tao_vfr.location_forwarded ()) + { + _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL); + _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + } + ACE_CATCHANY + { + _tao_ri.exception (&ACE_ANY_EXCEPTION); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION + || _tao_status == PortableInterceptor::USER_EXCEPTION) + { + ACE_RE_THROW; + } + } + +# if defined (ACE_HAS_EXCEPTIONS) \ + && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS) + ACE_CATCHALL + { + CORBA::UNKNOWN ex; + + _tao_ri.exception (&ex); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION) + ACE_TRY_THROW (ex); + } +# endif /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */ + ACE_ENDTRY; + ACE_CHECK; +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_server_request.init_reply (); + + // In case _tao_servant_upcall is not used in this function + ACE_UNUSED_ARG (_tao_servant_upcall); +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_ss.cpp:98 + +void POA_ImplementationRepository::Administration::server_is_running_skel ( + TAO_ServerRequest &_tao_server_request, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_ImplementationRepository::Administration *_tao_impl = + static_cast< + POA_ImplementationRepository::Administration *> ( + _tao_servant + ); + _tao_server_request.argument_flag (0); + + ::CORBA::String_var server; + ::CORBA::String_var partial_ior; + ::ImplementationRepository::ServerObject_var server_object; + + if (!( + (_tao_in >> server.out ()) && + (_tao_in >> partial_ior.out ()) && + (_tao_in >> server_object.out ()) + )) + { + TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + +#if (TAO_HAS_INTERCEPTORS == 1) + TAO::Portable_Server::Servant_Upcall *_tao_upcall = + static_cast< + TAO::Portable_Server::Servant_Upcall *> ( + _tao_servant_upcall + ); + + TAO_ServerRequestInterceptor_Adapter _tao_vfr ( + _tao_server_request.orb_core ()->server_request_interceptors (), + _tao_server_request.interceptor_count () + ); + + TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_running _tao_ri ( + _tao_server_request, + _tao_upcall, + _tao_impl, + + server.in (), + + partial_ior.in (), + + server_object.in () + ACE_ENV_ARG_PARAMETER + ); + + ACE_TRY + { + { + TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (), + true /* Copy TSC to RSC */); + + _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (!_tao_vfr.location_forwarded ()) + { +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_impl->server_is_running ( + server.in (), + + partial_ior.in (), + + server_object.in () + ACE_ENV_ARG_PARAMETER + ); + TAO_INTERCEPTOR_CHECK; +#if (TAO_HAS_INTERCEPTORS == 1) + } + } + + if (!_tao_vfr.location_forwarded ()) + { + _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL); + _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + } + ACE_CATCHANY + { + _tao_ri.exception (&ACE_ANY_EXCEPTION); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION + || _tao_status == PortableInterceptor::USER_EXCEPTION) + { + ACE_RE_THROW; + } + } + +# if defined (ACE_HAS_EXCEPTIONS) \ + && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS) + ACE_CATCHALL + { + CORBA::UNKNOWN ex; + + _tao_ri.exception (&ex); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION) + ACE_TRY_THROW (ex); + } +# endif /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */ + ACE_ENDTRY; + ACE_CHECK; +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_server_request.init_reply (); + + // In case _tao_servant_upcall is not used in this function + ACE_UNUSED_ARG (_tao_servant_upcall); +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_ss.cpp:98 + +void POA_ImplementationRepository::Administration::server_is_shutting_down_skel ( + TAO_ServerRequest &_tao_server_request, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_ImplementationRepository::Administration *_tao_impl = + static_cast< + POA_ImplementationRepository::Administration *> ( + _tao_servant + ); + _tao_server_request.argument_flag (0); + + ::CORBA::String_var server; + + if (!( + (_tao_in >> server.out ()) + )) + { + TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + +#if (TAO_HAS_INTERCEPTORS == 1) + TAO::Portable_Server::Servant_Upcall *_tao_upcall = + static_cast< + TAO::Portable_Server::Servant_Upcall *> ( + _tao_servant_upcall + ); + + TAO_ServerRequestInterceptor_Adapter _tao_vfr ( + _tao_server_request.orb_core ()->server_request_interceptors (), + _tao_server_request.interceptor_count () + ); + + TAO_ServerRequestInfo_ImplementationRepository_Administration_server_is_shutting_down _tao_ri ( + _tao_server_request, + _tao_upcall, + _tao_impl, + + server.in () + ACE_ENV_ARG_PARAMETER + ); + + ACE_TRY + { + { + TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (), + true /* Copy TSC to RSC */); + + _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (!_tao_vfr.location_forwarded ()) + { +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_impl->server_is_shutting_down ( + server.in () + ACE_ENV_ARG_PARAMETER + ); + TAO_INTERCEPTOR_CHECK; +#if (TAO_HAS_INTERCEPTORS == 1) + } + } + + if (!_tao_vfr.location_forwarded ()) + { + _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL); + _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + } + ACE_CATCHANY + { + _tao_ri.exception (&ACE_ANY_EXCEPTION); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION + || _tao_status == PortableInterceptor::USER_EXCEPTION) + { + ACE_RE_THROW; + } + } + +# if defined (ACE_HAS_EXCEPTIONS) \ + && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS) + ACE_CATCHALL + { + CORBA::UNKNOWN ex; + + _tao_ri.exception (&ex); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION) + ACE_TRY_THROW (ex); + } +# endif /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */ + ACE_ENDTRY; + ACE_CHECK; +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_server_request.init_reply (); + + // In case _tao_servant_upcall is not used in this function + ACE_UNUSED_ARG (_tao_servant_upcall); +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_ss.cpp:98 + +void POA_ImplementationRepository::Administration::find_skel ( + TAO_ServerRequest &_tao_server_request, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_ImplementationRepository::Administration *_tao_impl = + static_cast< + POA_ImplementationRepository::Administration *> ( + _tao_servant + ); + + ::CORBA::String_var server; + ::ImplementationRepository::ServerInformation_var info; + + if (!( + (_tao_in >> server.out ()) + )) + { + TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + +#if (TAO_HAS_INTERCEPTORS == 1) + TAO::Portable_Server::Servant_Upcall *_tao_upcall = + static_cast< + TAO::Portable_Server::Servant_Upcall *> ( + _tao_servant_upcall + ); + + TAO_ServerRequestInterceptor_Adapter _tao_vfr ( + _tao_server_request.orb_core ()->server_request_interceptors (), + _tao_server_request.interceptor_count () + ); + + TAO_ServerRequestInfo_ImplementationRepository_Administration_find _tao_ri ( + _tao_server_request, + _tao_upcall, + _tao_impl, + + server.in () + ACE_ENV_ARG_PARAMETER + ); + + ACE_TRY + { + { + TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (), + true /* Copy TSC to RSC */); + + _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (!_tao_vfr.location_forwarded ()) + { +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_impl->find ( + server.in (), + + info.out () + ACE_ENV_ARG_PARAMETER + ); + TAO_INTERCEPTOR_CHECK; +#if (TAO_HAS_INTERCEPTORS == 1) + } + } + + if (!_tao_vfr.location_forwarded ()) + { + _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL); + _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + } + ACE_CATCHANY + { + _tao_ri.exception (&ACE_ANY_EXCEPTION); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION + || _tao_status == PortableInterceptor::USER_EXCEPTION) + { + ACE_RE_THROW; + } + } + +# if defined (ACE_HAS_EXCEPTIONS) \ + && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS) + ACE_CATCHALL + { + CORBA::UNKNOWN ex; + + _tao_ri.exception (&ex); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION) + ACE_TRY_THROW (ex); + } +# endif /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */ + ACE_ENDTRY; + ACE_CHECK; +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_server_request.init_reply (); +#if (TAO_HAS_INTERCEPTORS == 1) + if (!_tao_vfr.location_forwarded ()) + { +#endif /* TAO_HAS_INTERCEPTORS */ + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + + if (!( + (_tao_out << info.in ()) + )) + { + TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } +#if (TAO_HAS_INTERCEPTORS == 1) + } +#endif /* TAO_HAS_INTERCEPTORS */ + + + // In case _tao_servant_upcall is not used in this function + ACE_UNUSED_ARG (_tao_servant_upcall); +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_ss.cpp:98 + +void POA_ImplementationRepository::Administration::list_skel ( + TAO_ServerRequest &_tao_server_request, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_ImplementationRepository::Administration *_tao_impl = + static_cast< + POA_ImplementationRepository::Administration *> ( + _tao_servant + ); + + ::CORBA::ULong how_many; + ::ImplementationRepository::ServerInformationList_var server_list; + + ::ImplementationRepository::ServerInformationIterator_var server_iterator; + + if (!( + (_tao_in >> how_many) + )) + { + TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + +#if (TAO_HAS_INTERCEPTORS == 1) + TAO::Portable_Server::Servant_Upcall *_tao_upcall = + static_cast< + TAO::Portable_Server::Servant_Upcall *> ( + _tao_servant_upcall + ); + + TAO_ServerRequestInterceptor_Adapter _tao_vfr ( + _tao_server_request.orb_core ()->server_request_interceptors (), + _tao_server_request.interceptor_count () + ); + + TAO_ServerRequestInfo_ImplementationRepository_Administration_list _tao_ri ( + _tao_server_request, + _tao_upcall, + _tao_impl, + + how_many + + ACE_ENV_ARG_PARAMETER + ); + + ACE_TRY + { + { + TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (), + true /* Copy TSC to RSC */); + + _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (!_tao_vfr.location_forwarded ()) + { +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_impl->list ( + how_many, + + server_list.out (), + + server_iterator.out () + ACE_ENV_ARG_PARAMETER + ); + TAO_INTERCEPTOR_CHECK; +#if (TAO_HAS_INTERCEPTORS == 1) + } + } + + if (!_tao_vfr.location_forwarded ()) + { + _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL); + _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + } + ACE_CATCHANY + { + _tao_ri.exception (&ACE_ANY_EXCEPTION); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION + || _tao_status == PortableInterceptor::USER_EXCEPTION) + { + ACE_RE_THROW; + } + } + +# if defined (ACE_HAS_EXCEPTIONS) \ + && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS) + ACE_CATCHALL + { + CORBA::UNKNOWN ex; + + _tao_ri.exception (&ex); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION) + ACE_TRY_THROW (ex); + } +# endif /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */ + ACE_ENDTRY; + ACE_CHECK; +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_server_request.init_reply (); +#if (TAO_HAS_INTERCEPTORS == 1) + if (!_tao_vfr.location_forwarded ()) + { +#endif /* TAO_HAS_INTERCEPTORS */ + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + + if (!( + (_tao_out << server_list.in ()) && + (_tao_out << server_iterator.in ()) + )) + { + TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } +#if (TAO_HAS_INTERCEPTORS == 1) + } +#endif /* TAO_HAS_INTERCEPTORS */ + + + // In case _tao_servant_upcall is not used in this function + ACE_UNUSED_ARG (_tao_servant_upcall); +} + +// TAO_IDL - Generated from +// be\be_visitor_interface/interface_ss.cpp:162 + +void POA_ImplementationRepository::Administration::_is_a_skel ( + TAO_ServerRequest &_tao_server_request, + void * _tao_servant, + void * /* Servant_Upcall */ + ACE_ENV_ARG_DECL + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + + POA_ImplementationRepository::Administration *_tao_impl = + static_cast<POA_ImplementationRepository::Administration *> (_tao_servant); + + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + + if (!(_tao_in >> value.out ())) + { + ACE_THROW (CORBA::MARSHAL ()); + } + + _tao_retval = _tao_impl->_is_a (value.in () ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + _tao_server_request.init_reply (); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + + if (!(_tao_out << CORBA::Any::from_boolean (_tao_retval))) + { + ACE_THROW (CORBA::MARSHAL ()); + } +} + +void POA_ImplementationRepository::Administration::_non_existent_skel ( + TAO_ServerRequest &_tao_server_request, + void * _tao_servant, + void * /* Servant_Upcall */ + ACE_ENV_ARG_DECL + ) +{ + POA_ImplementationRepository::Administration *_tao_impl = + static_cast<POA_ImplementationRepository::Administration *> (_tao_servant); + + CORBA::Boolean _tao_retval = + _tao_impl->_non_existent (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + _tao_server_request.init_reply (); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + + if (!(_tao_out << CORBA::Any::from_boolean (_tao_retval))) + { + ACE_THROW (CORBA::MARSHAL ()); + } +} + +void POA_ImplementationRepository::Administration::_interface_skel ( + TAO_ServerRequest &_tao_server_request, + void * _tao_servant, + void * /* Servant_Upcall */ + ACE_ENV_ARG_DECL + ) +{ + TAO_IFR_Client_Adapter *_tao_adapter = + ACE_Dynamic_Service<TAO_IFR_Client_Adapter>::instance ( + TAO_ORB_Core::ifr_client_adapter_name () + ); + + if (_tao_adapter == 0) + { + ACE_THROW (CORBA::INTF_REPOS ()); + } + + POA_ImplementationRepository::Administration *_tao_impl = + static_cast<POA_ImplementationRepository::Administration *> (_tao_servant); + + CORBA::InterfaceDef_ptr _tao_retval = + _tao_impl->_get_interface (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + _tao_server_request.init_reply (); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + + CORBA::Boolean _tao_result = + _tao_adapter->interfacedef_cdr_insert ( + _tao_out, + _tao_retval + ); + + _tao_adapter->dispose (_tao_retval); + + if (_tao_result == 0) + { + ACE_THROW (CORBA::MARSHAL ()); + } +} + +void POA_ImplementationRepository::Administration::_component_skel ( + TAO_ServerRequest &_tao_server_request, + void * _tao_object_reference, + void * /* Servant_Upcall */ + ACE_ENV_ARG_DECL + ) +{ + POA_ImplementationRepository::Administration *_tao_impl = + static_cast<POA_ImplementationRepository::Administration *> (_tao_object_reference); + + CORBA::Object_var _tao_retval = + _tao_impl->_get_component (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + _tao_server_request.init_reply (); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + + if (!(_tao_out << _tao_retval.in ())) + { + ACE_THROW (CORBA::MARSHAL ()); + } +} + +CORBA::Boolean POA_ImplementationRepository::Administration::_is_a ( + const char* value + ACE_ENV_ARG_DECL_NOT_USED + ) +{ + return + ( + !ACE_OS::strcmp ( + value, + "IDL:ImplementationRepository/Administration:1.0" + ) || + !ACE_OS::strcmp ( + value, + "IDL:omg.org/CORBA/Object:1.0" + ) + ); +} + +void* POA_ImplementationRepository::Administration::_downcast ( + const char* logical_type_id + ) +{ + if (ACE_OS::strcmp (logical_type_id, + "IDL:ImplementationRepository/Administration:1.0") == 0) + { + return static_cast<POA_ImplementationRepository::Administration_ptr> (this); + } + + if (ACE_OS::strcmp (logical_type_id, + "IDL:omg.org/CORBA/Object:1.0") == 0) + { + return static_cast<PortableServer::Servant> (this); + } + + return 0; +} + +const char* POA_ImplementationRepository::Administration::_interface_repository_id (void) const +{ + return "IDL:ImplementationRepository/Administration:1.0"; +} + +// TAO_IDL - Generated from +// be\be_visitor_interface/interface_ss.cpp:576 + +void POA_ImplementationRepository::Administration::_dispatch ( + TAO_ServerRequest &req, + void *servant_upcall + ACE_ENV_ARG_DECL + ) +{ + this->synchronous_upcall_dispatch (req, + servant_upcall, + this + ACE_ENV_ARG_PARAMETER); +} + +// TAO_IDL - Generated from +// be\be_visitor_interface/interface_ss.cpp:527 + +ImplementationRepository::Administration * +POA_ImplementationRepository::Administration::_this (ACE_ENV_SINGLE_ARG_DECL) +{ + TAO_Stub *stub = this->_create_stub (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + TAO_Stub_Auto_Ptr safe_stub (stub); + CORBA::Object_ptr tmp = CORBA::Object::_nil (); + + CORBA::Boolean _tao_opt_colloc = + stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects (); + + ACE_NEW_RETURN ( + tmp, + CORBA::Object (stub, _tao_opt_colloc, this), + 0 + ); + + CORBA::Object_var obj = tmp; + (void) safe_stub.release (); + + typedef ::ImplementationRepository::Administration STUB_SCOPED_NAME; + return + TAO::Narrow_Utils<STUB_SCOPED_NAME>::unchecked_narrow ( + obj.in (), + ImplementationRepository__TAO_Administration_Proxy_Broker_Factory_function_pointer + ); +} + +// TAO_IDL - Generated from +// be\be_visitor_root/root.cpp:1683 + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVEROBJECT__SARG_TRAITS_TMPLINST_SS_) +#define _IMPLEMENTATIONREPOSITORY_SERVEROBJECT__SARG_TRAITS_TMPLINST_SS_ + + template class TAO::SArg_Traits<ImplementationRepository::ServerObject>; + + template class + TAO::Object_SArg_Traits_T< + ImplementationRepository::ServerObject_ptr, + ImplementationRepository::ServerObject_var, + ImplementationRepository::ServerObject_out, + >; + +#endif /* end #if !defined */ + +#if !defined (_IMPLEMENTATIONREPOSITORY_STARTUPOPTIONS__SARG_TRAITS_TMPLINST_SS_) +#define _IMPLEMENTATIONREPOSITORY_STARTUPOPTIONS__SARG_TRAITS_TMPLINST_SS_ + + template class TAO::SArg_Traits<ImplementationRepository::StartupOptions>; + + template class + TAO::Var_Size_SArg_Traits_T< + ImplementationRepository::StartupOptions, + ImplementationRepository::StartupOptions_var, + ImplementationRepository::StartupOptions_out + >; + +#endif /* end #if !defined */ + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATION__SARG_TRAITS_TMPLINST_SS_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATION__SARG_TRAITS_TMPLINST_SS_ + + template class TAO::SArg_Traits<ImplementationRepository::ServerInformation>; + + template class + TAO::Var_Size_SArg_Traits_T< + ImplementationRepository::ServerInformation, + ImplementationRepository::ServerInformation_var, + ImplementationRepository::ServerInformation_out + >; + +#endif /* end #if !defined */ + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST__SARG_TRAITS_TMPLINST_SS_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST__SARG_TRAITS_TMPLINST_SS_ + + template class TAO::SArg_Traits<ImplementationRepository::ServerInformationList>; + + template class + TAO::Var_Size_SArg_Traits_T< + ImplementationRepository::ServerInformationList, + ImplementationRepository::ServerInformationList_var, + ImplementationRepository::ServerInformationList_out + >; + +#endif /* end #if !defined */ + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR__SARG_TRAITS_TMPLINST_SS_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR__SARG_TRAITS_TMPLINST_SS_ + + template class TAO::SArg_Traits<ImplementationRepository::ServerInformationIterator>; + + template class + TAO::Object_SArg_Traits_T< + ImplementationRepository::ServerInformationIterator_ptr, + ImplementationRepository::ServerInformationIterator_var, + ImplementationRepository::ServerInformationIterator_out, + >; + +#endif /* end #if !defined */ + + template class + TAO::Out_Var_Size_SArgument_T< + ImplementationRepository::ServerInformationList, + ImplementationRepository::ServerInformationList_out + >; + + template class + TAO::In_Var_Size_SArgument_T< + ImplementationRepository::StartupOptions + >; + + template class + TAO::In_Object_SArgument_T< + ImplementationRepository::ServerObject_ptr + >; + + template class + TAO::Out_Var_Size_SArgument_T< + ImplementationRepository::ServerInformation, + ImplementationRepository::ServerInformation_out + >; + + template class + TAO::Out_Object_SArgument_T< + ImplementationRepository::ServerInformationIterator_ptr, + ImplementationRepository::ServerInformationIterator_out + >; + +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVEROBJECT__SARG_TRAITS_TMPLINST_SS_) +#define _IMPLEMENTATIONREPOSITORY_SERVEROBJECT__SARG_TRAITS_TMPLINST_SS_ + +# pragma instantiate TAO::SArg_Traits<ImplementationRepository::ServerObject> + +# pragma instantiate \ + TAO::Object_SArg_Traits_T< \ + ImplementationRepository::ServerObject_ptr, \ + ImplementationRepository::ServerObject_var, \ + ImplementationRepository::ServerObject_out, \ + > + +#endif /* end #if !defined */ + +#if !defined (_IMPLEMENTATIONREPOSITORY_STARTUPOPTIONS__SARG_TRAITS_TMPLINST_SS_) +#define _IMPLEMENTATIONREPOSITORY_STARTUPOPTIONS__SARG_TRAITS_TMPLINST_SS_ + +# pragma instantiate TAO::SArg_Traits<ImplementationRepository::StartupOptions> + +# pragma instantiate \ + TAO::Var_Size_SArg_Traits_T< \ + ImplementationRepository::StartupOptions, \ + ImplementationRepository::StartupOptions_var, \ + ImplementationRepository::StartupOptions_out \ + > + +#endif /* end #if !defined */ + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATION__SARG_TRAITS_TMPLINST_SS_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATION__SARG_TRAITS_TMPLINST_SS_ + +# pragma instantiate TAO::SArg_Traits<ImplementationRepository::ServerInformation> + +# pragma instantiate \ + TAO::Var_Size_SArg_Traits_T< \ + ImplementationRepository::ServerInformation, \ + ImplementationRepository::ServerInformation_var, \ + ImplementationRepository::ServerInformation_out \ + > + +#endif /* end #if !defined */ + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST__SARG_TRAITS_TMPLINST_SS_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST__SARG_TRAITS_TMPLINST_SS_ + +# pragma instantiate TAO::SArg_Traits<ImplementationRepository::ServerInformationList> + +# pragma instantiate \ + TAO::Var_Size_SArg_Traits_T< \ + ImplementationRepository::ServerInformationList, \ + ImplementationRepository::ServerInformationList_var, \ + ImplementationRepository::ServerInformationList_out \ + > + +#endif /* end #if !defined */ + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR__SARG_TRAITS_TMPLINST_SS_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR__SARG_TRAITS_TMPLINST_SS_ + +# pragma instantiate TAO::SArg_Traits<ImplementationRepository::ServerInformationIterator> + +# pragma instantiate \ + TAO::Object_SArg_Traits_T< \ + ImplementationRepository::ServerInformationIterator_ptr, \ + ImplementationRepository::ServerInformationIterator_var, \ + ImplementationRepository::ServerInformationIterator_out, \ + > + +#endif /* end #if !defined */ + +# pragma instantiate \ + TAO::Out_Var_Size_SArgument_T< \ + ImplementationRepository::ServerInformationList, \ + ImplementationRepository::ServerInformationList_out \ + > + +# pragma instantiate \ + TAO::In_Var_Size_SArgument_T< \ + ImplementationRepository::StartupOptions \ + > + +# pragma instantiate \ + TAO::In_Object_SArgument_T< \ + ImplementationRepository::ServerObject_ptr \ + > + +# pragma instantiate \ + TAO::Out_Var_Size_SArgument_T< \ + ImplementationRepository::ServerInformation, \ + ImplementationRepository::ServerInformation_out \ + > + +# pragma instantiate \ + TAO::Out_Object_SArgument_T< \ + ImplementationRepository::ServerInformationIterator_ptr, \ + ImplementationRepository::ServerInformationIterator_out \ + > + +#endif /* !ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +#endif /* ifndef */ + diff --git a/TAO/tao/ImR_Client/ImplRepoS.h b/TAO/tao/ImR_Client/ImplRepoS.h new file mode 100644 index 00000000000..fa566c3ab7a --- /dev/null +++ b/TAO/tao/ImR_Client/ImplRepoS.h @@ -0,0 +1,950 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// and +// Institute for Software Integrated Systems +// Vanderbilt University +// Nashville, TN +// USA +// http://www.isis.vanderbilt.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +// TAO_IDL - Generated from +// be\be_codegen.cpp:390 + +#ifndef _TAO_IDL_ORIG_IMPLREPOS_H_ +#define _TAO_IDL_ORIG_IMPLREPOS_H_ + +#include /**/ "ace/pre.h" + +#include "tao/ImR_Client/ServerObjectS.h" +#include "ImplRepoC.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "tao/Collocation_Proxy_Broker.h" +#include "tao/PortableServer/PortableServer.h" +#include "tao/PortableServer/Servant_Base.h" + +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option push -w-rvl -w-rch -w-ccc -w-inl +#endif /* __BORLANDC__ */ + +// TAO_IDL - Generated from +// be\be_visitor_module/module_sh.cpp:49 + +namespace POA_ImplementationRepository +{ + + + // TAO_IDL - Generated from + // be\be_visitor_interface/interface_sh.cpp:87 + + class ServerInformationIterator; + typedef ServerInformationIterator *ServerInformationIterator_ptr; + + class _TAO_ServerInformationIterator_ThruPOA_Proxy_Impl; + class _TAO_ServerInformationIterator_Direct_Proxy_Impl; + class _TAO_ServerInformationIterator_Strategized_Proxy_Broker; + + class TAO_IMR_Client_Export ServerInformationIterator + : public virtual PortableServer::ServantBase + { + protected: + ServerInformationIterator (void); + + public: + // Useful for template programming. + typedef ::ImplementationRepository::ServerInformationIterator _stub_type; + typedef ::ImplementationRepository::ServerInformationIterator_ptr _stub_ptr_type; + typedef ::ImplementationRepository::ServerInformationIterator_var _stub_var_type; + + ServerInformationIterator (const ServerInformationIterator& rhs); + virtual ~ServerInformationIterator (void); + + virtual CORBA::Boolean _is_a ( + const char* logical_type_id + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + virtual void* _downcast ( + const char* logical_type_id + ); + + static void _is_a_skel ( + TAO_ServerRequest &req, + void *servant, + void *servant_upcall + ACE_ENV_ARG_DECL + ); + + static void _non_existent_skel ( + TAO_ServerRequest &req, + void *servant, + void *servant_upcall + ACE_ENV_ARG_DECL + ); + + static void _interface_skel ( + TAO_ServerRequest &req, + void *servant, + void *servant_upcall + ACE_ENV_ARG_DECL + ); + + static void _component_skel ( + TAO_ServerRequest &req, + void *obj, + void *servant_upcall + ACE_ENV_ARG_DECL + ); + + virtual void _dispatch ( + TAO_ServerRequest &req, + void *_servant_upcall + ACE_ENV_ARG_DECL + ); + + ::ImplementationRepository::ServerInformationIterator *_this ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ); + + virtual const char* _interface_repository_id (void) const; + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_sh.cpp:45 + + virtual CORBA::Boolean next_n ( + ::CORBA::ULong how_many, + ::ImplementationRepository::ServerInformationList_out servers + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + static void next_n_skel ( + TAO_ServerRequest &_tao_req, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ); + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_sh.cpp:45 + + virtual void destroy ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + static void destroy_skel ( + TAO_ServerRequest &_tao_req, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ); + }; + + /////////////////////////////////////////////////////////////////////// + // Strategized Proxy Broker Declaration + // + + // TAO_IDL - Generated from + // be\be_visitor_interface/strategized_proxy_broker_sh.cpp:36 + + class TAO_IMR_Client_Export _TAO_ServerInformationIterator_Strategized_Proxy_Broker + : public virtual TAO::Collocation_Proxy_Broker + { + public: + _TAO_ServerInformationIterator_Strategized_Proxy_Broker (void); + + virtual ~_TAO_ServerInformationIterator_Strategized_Proxy_Broker (void); + + TAO::Collocation_Strategy + get_strategy ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void + dispatch ( + CORBA::Object_ptr obj, + CORBA::Object_out forward_obj, + TAO::Argument ** args, + int num_args, + const char * op, + size_t op_len, + TAO::Collocation_Strategy strategy + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::Exception)); + + static _TAO_ServerInformationIterator_Strategized_Proxy_Broker * + the_TAO_ServerInformationIterator_Strategized_Proxy_Broker (void); + }; + + // + // End Strategized Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + + + /////////////////////////////////////////////////////////////////////// + // ThruPOA Proxy Impl. Declaration + // + + // TAO_IDL - Generated from + // be\be_visitor_interface/thru_poa_proxy_impl_sh.cpp:37 + + class TAO_IMR_Client_Export _TAO_ServerInformationIterator_ThruPOA_Proxy_Impl + { + public: + _TAO_ServerInformationIterator_ThruPOA_Proxy_Impl (void); + + virtual ~_TAO_ServerInformationIterator_ThruPOA_Proxy_Impl (void) {} + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + next_n ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + destroy ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + }; + + // + // ThruPOA Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// + + // TAO_IDL - Generated from + // be\be_visitor_interface/direct_proxy_impl_sh.cpp:31 + + /////////////////////////////////////////////////////////////////////// + // Direct Impl. Declaration + // + + class TAO_IMR_Client_Export _TAO_ServerInformationIterator_Direct_Proxy_Impl + { + public: + _TAO_ServerInformationIterator_Direct_Proxy_Impl (void); + + virtual ~_TAO_ServerInformationIterator_Direct_Proxy_Impl (void) {} + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + next_n ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + destroy ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + }; + + // + // Direct Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// + + + + // TAO_IDL - Generated from + // be\be_visitor_interface/interface_sh.cpp:87 + + class Administration; + typedef Administration *Administration_ptr; + + class _TAO_Administration_ThruPOA_Proxy_Impl; + class _TAO_Administration_Direct_Proxy_Impl; + class _TAO_Administration_Strategized_Proxy_Broker; + + class TAO_IMR_Client_Export Administration + : public virtual PortableServer::ServantBase + { + protected: + Administration (void); + + public: + // Useful for template programming. + typedef ::ImplementationRepository::Administration _stub_type; + typedef ::ImplementationRepository::Administration_ptr _stub_ptr_type; + typedef ::ImplementationRepository::Administration_var _stub_var_type; + + Administration (const Administration& rhs); + virtual ~Administration (void); + + virtual CORBA::Boolean _is_a ( + const char* logical_type_id + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + virtual void* _downcast ( + const char* logical_type_id + ); + + static void _is_a_skel ( + TAO_ServerRequest &req, + void *servant, + void *servant_upcall + ACE_ENV_ARG_DECL + ); + + static void _non_existent_skel ( + TAO_ServerRequest &req, + void *servant, + void *servant_upcall + ACE_ENV_ARG_DECL + ); + + static void _interface_skel ( + TAO_ServerRequest &req, + void *servant, + void *servant_upcall + ACE_ENV_ARG_DECL + ); + + static void _component_skel ( + TAO_ServerRequest &req, + void *obj, + void *servant_upcall + ACE_ENV_ARG_DECL + ); + + virtual void _dispatch ( + TAO_ServerRequest &req, + void *_servant_upcall + ACE_ENV_ARG_DECL + ); + + ::ImplementationRepository::Administration *_this ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ); + + virtual const char* _interface_repository_id (void) const; + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_sh.cpp:45 + + virtual void activate_server ( + const char * server + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound, + ::ImplementationRepository::CannotActivate + )) = 0; + + static void activate_server_skel ( + TAO_ServerRequest &_tao_req, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ); + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_sh.cpp:45 + + virtual void register_server ( + const char * server, + const ::ImplementationRepository::StartupOptions & options + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::AlreadyRegistered, + ::ImplementationRepository::NotFound + )) = 0; + + static void register_server_skel ( + TAO_ServerRequest &_tao_req, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ); + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_sh.cpp:45 + + virtual void reregister_server ( + const char * server, + const ::ImplementationRepository::StartupOptions & options + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::AlreadyRegistered, + ::ImplementationRepository::NotFound + )) = 0; + + static void reregister_server_skel ( + TAO_ServerRequest &_tao_req, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ); + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_sh.cpp:45 + + virtual void remove_server ( + const char * server + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )) = 0; + + static void remove_server_skel ( + TAO_ServerRequest &_tao_req, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ); + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_sh.cpp:45 + + virtual void shutdown_server ( + const char * server + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )) = 0; + + static void shutdown_server_skel ( + TAO_ServerRequest &_tao_req, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ); + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_sh.cpp:45 + + virtual void server_is_running ( + const char * server, + const char * partial_ior, + ::ImplementationRepository::ServerObject_ptr server_object + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )) = 0; + + static void server_is_running_skel ( + TAO_ServerRequest &_tao_req, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ); + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_sh.cpp:45 + + virtual void server_is_shutting_down ( + const char * server + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )) = 0; + + static void server_is_shutting_down_skel ( + TAO_ServerRequest &_tao_req, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ); + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_sh.cpp:45 + + virtual void find ( + const char * server, + ::ImplementationRepository::ServerInformation_out info + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )) = 0; + + static void find_skel ( + TAO_ServerRequest &_tao_req, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ); + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_sh.cpp:45 + + virtual void list ( + ::CORBA::ULong how_many, + ::ImplementationRepository::ServerInformationList_out server_list, + ::ImplementationRepository::ServerInformationIterator_out server_iterator + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + static void list_skel ( + TAO_ServerRequest &_tao_req, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ); + }; + + /////////////////////////////////////////////////////////////////////// + // Strategized Proxy Broker Declaration + // + + // TAO_IDL - Generated from + // be\be_visitor_interface/strategized_proxy_broker_sh.cpp:36 + + class TAO_IMR_Client_Export _TAO_Administration_Strategized_Proxy_Broker + : public virtual TAO::Collocation_Proxy_Broker + { + public: + _TAO_Administration_Strategized_Proxy_Broker (void); + + virtual ~_TAO_Administration_Strategized_Proxy_Broker (void); + + TAO::Collocation_Strategy + get_strategy ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void + dispatch ( + CORBA::Object_ptr obj, + CORBA::Object_out forward_obj, + TAO::Argument ** args, + int num_args, + const char * op, + size_t op_len, + TAO::Collocation_Strategy strategy + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::Exception)); + + static _TAO_Administration_Strategized_Proxy_Broker * + the_TAO_Administration_Strategized_Proxy_Broker (void); + }; + + // + // End Strategized Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + + + /////////////////////////////////////////////////////////////////////// + // ThruPOA Proxy Impl. Declaration + // + + // TAO_IDL - Generated from + // be\be_visitor_interface/thru_poa_proxy_impl_sh.cpp:37 + + class TAO_IMR_Client_Export _TAO_Administration_ThruPOA_Proxy_Impl + { + public: + _TAO_Administration_ThruPOA_Proxy_Impl (void); + + virtual ~_TAO_Administration_ThruPOA_Proxy_Impl (void) {} + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + activate_server ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound, + ::ImplementationRepository::CannotActivate + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + register_server ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::AlreadyRegistered, + ::ImplementationRepository::NotFound + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + reregister_server ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::AlreadyRegistered, + ::ImplementationRepository::NotFound + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + remove_server ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + shutdown_server ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + server_is_running ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + server_is_shutting_down ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + find ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + list ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + }; + + // + // ThruPOA Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// + + // TAO_IDL - Generated from + // be\be_visitor_interface/direct_proxy_impl_sh.cpp:31 + + /////////////////////////////////////////////////////////////////////// + // Direct Impl. Declaration + // + + class TAO_IMR_Client_Export _TAO_Administration_Direct_Proxy_Impl + { + public: + _TAO_Administration_Direct_Proxy_Impl (void); + + virtual ~_TAO_Administration_Direct_Proxy_Impl (void) {} + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + activate_server ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound, + ::ImplementationRepository::CannotActivate + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + register_server ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::AlreadyRegistered, + ::ImplementationRepository::NotFound + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + reregister_server ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::AlreadyRegistered, + ::ImplementationRepository::NotFound + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + remove_server ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + shutdown_server ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + server_is_running ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + server_is_shutting_down ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + find ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ::ImplementationRepository::NotFound + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + list ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + }; + + // + // Direct Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// + + + +// TAO_IDL - Generated from +// be\be_visitor_module/module_sh.cpp:80 + +} // module ImplementationRepository + +// TAO_IDL - Generated from +// be\be_codegen.cpp:997 + + +#if defined (__ACE_INLINE__) +#include "ImplRepoS.inl" +#endif /* defined INLINE */ + +#if defined(_MSC_VER) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option pop +#endif /* __BORLANDC__ */ + +#include /**/ "ace/post.h" +#endif /* ifndef */ + diff --git a/TAO/tao/ImR_Client/ImplRepoS.inl b/TAO/tao/ImR_Client/ImplRepoS.inl new file mode 100644 index 00000000000..c944d806c1f --- /dev/null +++ b/TAO/tao/ImR_Client/ImplRepoS.inl @@ -0,0 +1,27 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// and +// Institute for Software Integrated Systems +// Vanderbilt University +// Nashville, TN +// USA +// http://www.isis.vanderbilt.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + diff --git a/TAO/tao/ImR_Client/ServerObject.pidl b/TAO/tao/ImR_Client/ServerObject.pidl new file mode 100644 index 00000000000..9ed92faeb73 --- /dev/null +++ b/TAO/tao/ImR_Client/ServerObject.pidl @@ -0,0 +1,36 @@ +// -*- IDL -*- + +//============================================================================= +/** + * @file ServerObject.pidl + * + * $Id$ + * + * This file was used to generate the code in ServerObject{C,S}.{h,inl,cpp} + * + * The command used to generate code from this file is: + * + * tao_idl -Gp -Gd -Ge 1 -Sc -GT -Wb,export_macro=TAO_IMR_Client_Export -Wb,export_include=imr_client_export.h -Wb,pre_include="ace/pre.h" -Wb,post_include="ace/post.h" ServerObject.pidl + * + */ +//============================================================================= + +module ImplementationRepository +{ + /** + * @brief Server Side IR Object + * + * This object, which exists on the servers that use the + * Implementation Repository (IR), is used to control or check the + * status of the server by the IR. + */ + + interface ServerObject + { + /// Check the liveness of a server. + void ping (); + + /// Try to shutdown the server gracefully. + void shutdown (); + }; +}; diff --git a/TAO/tao/ImR_Client/ServerObjectA.cpp b/TAO/tao/ImR_Client/ServerObjectA.cpp new file mode 100644 index 00000000000..714d2b0801b --- /dev/null +++ b/TAO/tao/ImR_Client/ServerObjectA.cpp @@ -0,0 +1,143 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// and +// Institute for Software Integrated Systems +// Vanderbilt University +// Nashville, TN +// USA +// http://www.isis.vanderbilt.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +#include "ServerObjectC.h" +#include "tao/Typecode.h" +#include "tao/CDR.h" +#include "tao/Any.h" +#include "tao/Any_Impl_T.h" + +// TAO_IDL - Generated from +// be\be_visitor_typecode/typecode_defn.cpp:295 + +static const CORBA::Long _oc_ImplementationRepository_ServerObject[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 46, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x496d706c), + ACE_NTOHL (0x656d656e), + ACE_NTOHL (0x74617469), + ACE_NTOHL (0x6f6e5265), + ACE_NTOHL (0x706f7369), + ACE_NTOHL (0x746f7279), + ACE_NTOHL (0x2f536572), + ACE_NTOHL (0x7665724f), + ACE_NTOHL (0x626a6563), + ACE_NTOHL (0x743a312e), + ACE_NTOHL (0x30000000), // repository ID = IDL:ImplementationRepository/ServerObject:1.0 + 13, + ACE_NTOHL (0x53657276), + ACE_NTOHL (0x65724f62), + ACE_NTOHL (0x6a656374), + ACE_NTOHL (0x0), // name = ServerObject + }; + +static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerObject ( + CORBA::tk_objref, + sizeof (_oc_ImplementationRepository_ServerObject), + (char *) &_oc_ImplementationRepository_ServerObject, + 0, + 0 + ); + +namespace ImplementationRepository +{ + ::CORBA::TypeCode_ptr _tc_ServerObject = + &_tc_TAO_tc_ImplementationRepository_ServerObject; +} + +// TAO_IDL - Generated from +// be\be_visitor_interface/any_op_cs.cpp:50 + +ACE_TEMPLATE_SPECIALIZATION +CORBA::Boolean +TAO::Any_Impl_T<ImplementationRepository::ServerObject>::to_object ( + CORBA::Object_ptr &_tao_elem + ) const +{ + _tao_elem = CORBA::Object::_duplicate (this->value_); + return 1; +} + +// Copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + ImplementationRepository::ServerObject_ptr _tao_elem + ) +{ + ImplementationRepository::ServerObject_ptr _tao_objptr = + ImplementationRepository::ServerObject::_duplicate (_tao_elem); + _tao_any <<= &_tao_objptr; +} + +// Non-copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + ImplementationRepository::ServerObject_ptr *_tao_elem + ) +{ + TAO::Any_Impl_T<ImplementationRepository::ServerObject>::insert ( + _tao_any, + ImplementationRepository::ServerObject::_tao_any_destructor, + ImplementationRepository::_tc_ServerObject, + *_tao_elem + ); +} + +CORBA::Boolean +operator>>= ( + const CORBA::Any &_tao_any, + ImplementationRepository::ServerObject_ptr &_tao_elem + ) +{ + return + TAO::Any_Impl_T<ImplementationRepository::ServerObject>::extract ( + _tao_any, + ImplementationRepository::ServerObject::_tao_any_destructor, + ImplementationRepository::_tc_ServerObject, + _tao_elem + ); +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + + template class + TAO::Any_Impl_T< + ImplementationRepository::ServerObject + >; + +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + +# pragma instantiate \ + TAO::Any_Impl_T< \ + ImplementationRepository::ServerObject \ + > + +#endif /* !ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ diff --git a/TAO/tao/ImR_Client/ServerObjectC.cpp b/TAO/tao/ImR_Client/ServerObjectC.cpp new file mode 100644 index 00000000000..5ba981694ba --- /dev/null +++ b/TAO/tao/ImR_Client/ServerObjectC.cpp @@ -0,0 +1,373 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// and +// Institute for Software Integrated Systems +// Vanderbilt University +// Nashville, TN +// USA +// http://www.isis.vanderbilt.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +// TAO_IDL - Generated from +// be\be_codegen.cpp:302 + + +#include "ServerObjectC.h" +#include "tao/CDR.h" +#include "tao/Exception_Data.h" +#include "tao/Invocation_Adapter.h" +#include "tao/Object_T.h" +#include "tao/Basic_Arguments.h" +#include "ace/OS_NS_string.h" + +#if defined (__BORLANDC__) +#pragma option -w-rvl -w-rch -w-ccc -w-aus -w-sig +#endif /* __BORLANDC__ */ + +#if !defined (__ACE_INLINE__) +#include "ServerObjectC.inl" +#endif /* !defined INLINE */ + +// TAO_IDL - Generated from +// be\be_visitor_arg_traits.cpp:66 + +// Arg traits specializations. +namespace TAO +{ +} + + +// TAO_IDL - Generated from +// be\be_visitor_interface/interface_cs.cpp:60 + +// Traits specializations for ImplementationRepository::ServerObject. + +ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION +ImplementationRepository::ServerObject_ptr +TAO::Objref_Traits<ImplementationRepository::ServerObject>::duplicate ( + ImplementationRepository::ServerObject_ptr p + ) +{ + return ImplementationRepository::ServerObject::_duplicate (p); +} + +ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION +void +TAO::Objref_Traits<ImplementationRepository::ServerObject>::release ( + ImplementationRepository::ServerObject_ptr p + ) +{ + CORBA::release (p); +} + +ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION +ImplementationRepository::ServerObject_ptr +TAO::Objref_Traits<ImplementationRepository::ServerObject>::nil (void) +{ + return ImplementationRepository::ServerObject::_nil (); +} + +ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION +CORBA::Boolean +TAO::Objref_Traits<ImplementationRepository::ServerObject>::marshal ( + ImplementationRepository::ServerObject_ptr p, + TAO_OutputCDR & cdr + ) +{ + return CORBA::Object::marshal (p, cdr); +} + +// Function pointer for collocation factory initialization. +TAO::Collocation_Proxy_Broker * +(*ImplementationRepository__TAO_ServerObject_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_cs.cpp:78 + +void ImplementationRepository::ServerObject::ping ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + if (!this->is_evaluated ()) + { + ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this); + } + + if (this->the_TAO_ServerObject_Proxy_Broker_ == 0) + { + ImplementationRepository_ServerObject_setup_collocation (); + } + + TAO::Arg_Traits< void>::ret_val _tao_retval; + + TAO::Argument *_the_tao_operation_signature [] = + { + &_tao_retval + }; + + TAO::Invocation_Adapter _tao_call ( + this, + _the_tao_operation_signature, + 1, + "ping", + 4, + this->the_TAO_ServerObject_Proxy_Broker_ + ); + + _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER); + ACE_CHECK; +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_cs.cpp:78 + +void ImplementationRepository::ServerObject::shutdown ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + if (!this->is_evaluated ()) + { + ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this); + } + + if (this->the_TAO_ServerObject_Proxy_Broker_ == 0) + { + ImplementationRepository_ServerObject_setup_collocation (); + } + + TAO::Arg_Traits< void>::ret_val _tao_retval; + + TAO::Argument *_the_tao_operation_signature [] = + { + &_tao_retval + }; + + TAO::Invocation_Adapter _tao_call ( + this, + _the_tao_operation_signature, + 1, + "shutdown", + 8, + this->the_TAO_ServerObject_Proxy_Broker_ + ); + + _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER); + ACE_CHECK; +} + +ImplementationRepository::ServerObject::ServerObject (void) + : the_TAO_ServerObject_Proxy_Broker_ (0) +{ + this->ImplementationRepository_ServerObject_setup_collocation (); +} + +void +ImplementationRepository::ServerObject::ImplementationRepository_ServerObject_setup_collocation () +{ + if (::ImplementationRepository__TAO_ServerObject_Proxy_Broker_Factory_function_pointer) + { + this->the_TAO_ServerObject_Proxy_Broker_ = + ::ImplementationRepository__TAO_ServerObject_Proxy_Broker_Factory_function_pointer (this); + } +} + +ImplementationRepository::ServerObject::~ServerObject (void) +{} + +void +ImplementationRepository::ServerObject::_tao_any_destructor (void *_tao_void_pointer) +{ + ServerObject *_tao_tmp_pointer = + static_cast<ServerObject *> (_tao_void_pointer); + CORBA::release (_tao_tmp_pointer); +} + +ImplementationRepository::ServerObject_ptr +ImplementationRepository::ServerObject::_narrow ( + CORBA::Object_ptr _tao_objref + ACE_ENV_ARG_DECL + ) +{ + return + TAO::Narrow_Utils<ServerObject>::narrow ( + _tao_objref, + "IDL:ImplementationRepository/ServerObject:1.0", + ImplementationRepository__TAO_ServerObject_Proxy_Broker_Factory_function_pointer + ACE_ENV_ARG_PARAMETER + ); +} + +ImplementationRepository::ServerObject_ptr +ImplementationRepository::ServerObject::_unchecked_narrow ( + CORBA::Object_ptr _tao_objref + ACE_ENV_ARG_DECL + ) +{ + return + TAO::Narrow_Utils<ServerObject>::unchecked_narrow ( + _tao_objref, + "IDL:ImplementationRepository/ServerObject:1.0", + ImplementationRepository__TAO_ServerObject_Proxy_Broker_Factory_function_pointer + ACE_ENV_ARG_PARAMETER + ); +} + +ImplementationRepository::ServerObject_ptr +ImplementationRepository::ServerObject::_duplicate (ServerObject_ptr obj) +{ + if (! CORBA::is_nil (obj)) + { + obj->_add_ref (); + } + + return obj; +} + +CORBA::Boolean +ImplementationRepository::ServerObject::_is_a ( + const char *value + ACE_ENV_ARG_DECL + ) +{ + if ( + !ACE_OS::strcmp ( + value, + "IDL:ImplementationRepository/ServerObject:1.0" + ) || + !ACE_OS::strcmp ( + value, + "IDL:omg.org/CORBA/Object:1.0" + ) + ) + { + return 1; // success using local knowledge + } + else + { + return this->ACE_NESTED_CLASS (CORBA, Object)::_is_a ( + value + ACE_ENV_ARG_PARAMETER + ); + } +} + +const char* ImplementationRepository::ServerObject::_interface_repository_id (void) const +{ + return "IDL:ImplementationRepository/ServerObject:1.0"; +} + +CORBA::Boolean +ImplementationRepository::ServerObject::marshal (TAO_OutputCDR &cdr) +{ + return (cdr << this); +} + +// TAO_IDL - Generated from +// be\be_visitor_interface/cdr_op_cs.cpp:63 + +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const ImplementationRepository::ServerObject_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + ImplementationRepository::ServerObject_ptr &_tao_objref + ) +{ + CORBA::Object_var obj; + + if (!(strm >> obj.inout ())) + { + return false; + } + + typedef ::ImplementationRepository::ServerObject RHS_SCOPED_NAME; + + // Narrow to the right type. + _tao_objref = + TAO::Narrow_Utils<RHS_SCOPED_NAME>::unchecked_narrow ( + obj.in (), + ImplementationRepository__TAO_ServerObject_Proxy_Broker_Factory_function_pointer + ); + + return 1; +} + +// TAO_IDL - Generated from +// be\be_visitor_root/root.cpp:1629 + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + + template class + TAO::Objref_Traits< + ImplementationRepository::ServerObject + >; + + template class + TAO_Objref_Var_T< + ImplementationRepository::ServerObject + >; + + template class + TAO_Objref_Out_T< + ImplementationRepository::ServerObject + >; + + template class + TAO::Narrow_Utils< + ImplementationRepository::ServerObject + >; + +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + +# pragma instantiate \ + TAO::Objref_Traits< \ + ImplementationRepository::ServerObject \ + > + +# pragma instantiate \ + TAO_Objref_Var_T< \ + ImplementationRepository::ServerObject + > + +# pragma instantiate \ + TAO_Objref_Out_T< \ + ImplementationRepository::ServerObject + > + +# pragma instantiate \ + TAO::Narrow_Utils< \ + ImplementationRepository::ServerObject \ + > + +#endif /* !ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ diff --git a/TAO/tao/ImR_Client/ServerObjectC.h b/TAO/tao/ImR_Client/ServerObjectC.h new file mode 100644 index 00000000000..2b7620c4918 --- /dev/null +++ b/TAO/tao/ImR_Client/ServerObjectC.h @@ -0,0 +1,293 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// and +// Institute for Software Integrated Systems +// Vanderbilt University +// Nashville, TN +// USA +// http://www.isis.vanderbilt.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +// TAO_IDL - Generated from +// be\be_codegen.cpp:153 + +#ifndef _TAO_IDL_ORIG_SERVEROBJECTC_H_ +#define _TAO_IDL_ORIG_SERVEROBJECTC_H_ + +#include /**/ "ace/pre.h" + + +#include "ace/config-all.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "imr_client_export.h" +#include "tao/ORB.h" +#include "tao/SystemException.h" +#include "tao/Environment.h" +#include "tao/Object.h" +#include "tao/Objref_VarOut_T.h" + +#if defined (TAO_EXPORT_MACRO) +#undef TAO_EXPORT_MACRO +#endif +#define TAO_EXPORT_MACRO TAO_IMR_Client_Export + +#if defined (TAO_EXPORT_NESTED_CLASSES) +# if defined (TAO_EXPORT_NESTED_MACRO) +# undef TAO_EXPORT_NESTED_MACRO +# endif /* defined (TAO_EXPORT_NESTED_MACRO) */ +# define TAO_EXPORT_NESTED_MACRO TAO_IMR_Client_Export +#endif /* TAO_EXPORT_NESTED_CLASSES */ + +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option push -w-rvl -w-rch -w-ccc -w-inl +#endif /* __BORLANDC__ */ + +// TAO_IDL - Generated from +// be\be_visitor_root/root_ch.cpp:62 + +namespace TAO +{ + class Collocation_Proxy_Broker; + + template<typename T> class Narrow_Utils; + template<typename T> class AbstractBase_Narrow_Utils; +} + +// TAO_IDL - Generated from +// be\be_visitor_module/module_ch.cpp:48 + +namespace ImplementationRepository +{ + + // TAO_IDL - Generated from + // be\be_interface.cpp:598 + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVEROBJECT__VAR_OUT_CH_) +#define _IMPLEMENTATIONREPOSITORY_SERVEROBJECT__VAR_OUT_CH_ + + class ServerObject; + typedef ServerObject *ServerObject_ptr; + + typedef + TAO_Objref_Var_T< + ServerObject + > + ServerObject_var; + + typedef + TAO_Objref_Out_T< + ServerObject + > + ServerObject_out; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be\be_visitor_interface/interface_ch.cpp:54 + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVEROBJECT_CH_) +#define _IMPLEMENTATIONREPOSITORY_SERVEROBJECT_CH_ + + class TAO_IMR_Client_Export ServerObject + : public virtual CORBA::Object + { + public: + friend class TAO::Narrow_Utils<ServerObject>; + typedef ServerObject_ptr _ptr_type; + typedef ServerObject_var _var_type; + + // The static operations. + static ServerObject_ptr _duplicate (ServerObject_ptr obj); + + static ServerObject_ptr _narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static ServerObject_ptr _unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static ServerObject_ptr _nil (void) + { + return static_cast<ServerObject_ptr> (0); + } + + static void _tao_any_destructor (void *); + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_ch.cpp:46 + + virtual void ping ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_ch.cpp:46 + + virtual void shutdown ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + // TAO_IDL - Generated from + // be\be_visitor_interface/interface_ch.cpp:208 + + virtual CORBA::Boolean _is_a ( + const char *type_id + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + virtual const char* _interface_repository_id (void) const; + virtual CORBA::Boolean marshal (TAO_OutputCDR &cdr); + private: + TAO::Collocation_Proxy_Broker *the_TAO_ServerObject_Proxy_Broker_; + + protected: + // Concrete interface only. + ServerObject (void); + + // These methods travese the inheritance tree and set the + // parents piece of the given class in the right mode. + virtual void ImplementationRepository_ServerObject_setup_collocation (void); + + // Concrete non-local interface only. + ServerObject ( + IOP::IOR *ior, + TAO_ORB_Core *orb_core = 0 + ); + + // Non-local interface only. + ServerObject ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0, + TAO_ORB_Core *orb_core = 0 + ); + + virtual ~ServerObject (void); + + private: + // Private and unimplemented for concrete interfaces. + ServerObject (const ServerObject &); + + void operator= (const ServerObject &); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be\be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_ServerObject; + +// TAO_IDL - Generated from +// be\be_visitor_module/module_ch.cpp:66 + +} // module ImplementationRepository + +// Proxy Broker Factory function pointer declarations. + +// TAO_IDL - Generated from +// be\be_visitor_root/root.cpp:120 + +extern TAO_IMR_Client_Export +TAO::Collocation_Proxy_Broker * +(*ImplementationRepository__TAO_ServerObject_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); + +// TAO_IDL - Generated from +// be\be_visitor_traits.cpp:59 + +// Traits specializations. +namespace TAO +{ + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVEROBJECT__TRAITS_CH_) +#define _IMPLEMENTATIONREPOSITORY_SERVEROBJECT__TRAITS_CH_ + + ACE_TEMPLATE_SPECIALIZATION + struct TAO_IMR_Client_Export Objref_Traits< ::ImplementationRepository::ServerObject> + { + static ::ImplementationRepository::ServerObject_ptr duplicate ( + ::ImplementationRepository::ServerObject_ptr + ); + static void release ( + ::ImplementationRepository::ServerObject_ptr + ); + static ::ImplementationRepository::ServerObject_ptr nil (void); + static CORBA::Boolean marshal ( + ::ImplementationRepository::ServerObject_ptr p, + TAO_OutputCDR & cdr + ); + }; + +#endif /* end #if !defined */ +} + +// TAO_IDL - Generated from +// be\be_visitor_interface/any_op_ch.cpp:52 + +TAO_IMR_Client_Export void operator<<= (CORBA::Any &, ImplementationRepository::ServerObject_ptr); // copying +TAO_IMR_Client_Export void operator<<= (CORBA::Any &, ImplementationRepository::ServerObject_ptr *); // non-copying +TAO_IMR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::ServerObject_ptr &); + +// TAO_IDL - Generated from +// be\be_visitor_interface/cdr_op_ch.cpp:55 + +TAO_IMR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::ServerObject_ptr ); +TAO_IMR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::ServerObject_ptr &); + +// TAO_IDL - Generated from +// be\be_codegen.cpp:961 + +#if defined (__ACE_INLINE__) +#include "ServerObjectC.inl" +#endif /* defined INLINE */ + +#if defined(_MSC_VER) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option pop +#endif /* __BORLANDC__ */ + +#include /**/ "ace/post.h" + +#endif /* ifndef */ + + diff --git a/TAO/tao/ImR_Client/ServerObjectC.inl b/TAO/tao/ImR_Client/ServerObjectC.inl new file mode 100644 index 00000000000..7e8263d8d30 --- /dev/null +++ b/TAO/tao/ImR_Client/ServerObjectC.inl @@ -0,0 +1,63 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// and +// Institute for Software Integrated Systems +// Vanderbilt University +// Nashville, TN +// USA +// http://www.isis.vanderbilt.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + + +// TAO_IDL - Generated from +// be\be_visitor_interface/interface_ci.cpp:70 + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVEROBJECT___CI_) +#define _IMPLEMENTATIONREPOSITORY_SERVEROBJECT___CI_ + +ACE_INLINE +ImplementationRepository::ServerObject::ServerObject ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated, + TAO_Abstract_ServantBase *servant, + TAO_ORB_Core *oc + ) + : ACE_NESTED_CLASS (CORBA, Object) ( + objref, + _tao_collocated, + servant, + oc + ), + the_TAO_ServerObject_Proxy_Broker_ (0) +{ + this->ImplementationRepository_ServerObject_setup_collocation (); +} + +ACE_INLINE +ImplementationRepository::ServerObject::ServerObject ( + IOP::IOR *ior, + TAO_ORB_Core *oc + ) + : ACE_NESTED_CLASS (CORBA, Object) (ior, oc), + the_TAO_ServerObject_Proxy_Broker_ (0) +{ +} + +#endif /* end #if !defined */ diff --git a/TAO/tao/ImR_Client/ServerObjectS.cpp b/TAO/tao/ImR_Client/ServerObjectS.cpp new file mode 100644 index 00000000000..f8ebdd3ea44 --- /dev/null +++ b/TAO/tao/ImR_Client/ServerObjectS.cpp @@ -0,0 +1,1202 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// and +// Institute for Software Integrated Systems +// Vanderbilt University +// Nashville, TN +// USA +// http://www.isis.vanderbilt.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + + +// TAO_IDL - Generated from +// be\be_codegen.cpp:609 + +#ifndef _TAO_IDL_ORIG_SERVEROBJECTS_CPP_ +#define _TAO_IDL_ORIG_SERVEROBJECTS_CPP_ + + +#include "ServerObjectS.h" +#include "tao/PortableServer/Servant_Upcall.h" +#include "tao/PortableServer/ForwardRequestC.h" +#include "tao/PortableServer/Operation_Table.h" +#include "tao/TAO_Server_Request.h" +#include "tao/ORB_Core.h" +#include "tao/Profile.h" +#include "tao/Stub.h" +#include "tao/IFR_Client_Adapter.h" +#include "tao/Object_T.h" +#include "tao/Typecode.h" +#include "tao/DynamicC.h" +#include "tao/CDR.h" +#include "tao/Basic_Arguments.h" +#include "tao/PortableInterceptor.h" +#if TAO_HAS_INTERCEPTORS == 1 +#include "tao/PortableServer/PICurrent_Guard.h" +#include "tao/PortableServer/ServerRequestInfo.h" +#include "tao/PortableServer/ServerInterceptorAdapter.h" +#include "tao/RequestInfo_Util.h" +#endif /* TAO_HAS_INTERCEPTORS == 1 */ + +#include "ace/Dynamic_Service.h" +#include "ace/Malloc_Allocator.h" + +#if defined (__BORLANDC__) +#pragma option -w-rvl -w-rch -w-ccc -w-aus +#endif /* __BORLANDC__ */ + +#if !defined (__ACE_INLINE__) +#include "ServerObjectS.inl" +#endif /* !defined INLINE */ + +// TAO_IDL - Generated from +// be\be_visitor_arg_traits.cpp:66 + +// Arg traits specializations. +namespace TAO +{ +} + + +// TAO_IDL - Generated from +// be\be_interface.cpp:1536 + +class TAO_ImplementationRepository_ServerObject_Perfect_Hash_OpTable + : public TAO_Perfect_Hash_OpTable +{ +private: + unsigned int hash (const char *str, unsigned int len); + +public: + const TAO_operation_db_entry * lookup (const char *str, unsigned int len); +}; + +/* C++ code produced by gperf version 2.8 (ACE version) */ +/* Command-line: c:\ace\POArefactor3\ace_wrappers\bin\gperf.exe -m -M -J -c -C -D -E -T -f 0 -F 0,0,0 -a -o -t -p -K opname_ -L C++ -Z TAO_ImplementationRepository_ServerObject_Perfect_Hash_OpTable -N lookup */ +unsigned int +TAO_ImplementationRepository_ServerObject_Perfect_Hash_OpTable::hash (const char *str, unsigned int len) +{ + static const unsigned char asso_values[] = + { +#if defined (ACE_MVS) + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 0, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 0, + 16, 16, 16, 5, 16, 0, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 0, + 16, 0, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 0, 0, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, +#else + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 0, 16, 0, 16, 16, + 16, 5, 16, 0, 16, 16, 16, 16, 16, 16, + 0, 16, 0, 16, 16, 0, 0, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, +#endif /* ACE_MVS */ + }; + return len + asso_values[(int) str[len - 1]] + asso_values[(int) str[0]]; +} + +const class TAO_operation_db_entry * +TAO_ImplementationRepository_ServerObject_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len) +{ + enum + { + TOTAL_KEYWORDS = 6, + MIN_WORD_LENGTH = 4, + MAX_WORD_LENGTH = 13, + MIN_HASH_VALUE = 4, + MAX_HASH_VALUE = 15, + HASH_VALUE_RANGE = 12, + DUPLICATES = 0, + WORDLIST_SIZE = 10 + }; + + static const class TAO_operation_db_entry wordlist[] = + { + {"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0}, + {"ping", &POA_ImplementationRepository::ServerObject::ping_skel, &POA_ImplementationRepository::_TAO_ServerObject_ThruPOA_Proxy_Impl::ping, &POA_ImplementationRepository::_TAO_ServerObject_Direct_Proxy_Impl::ping}, + {"_is_a", &POA_ImplementationRepository::ServerObject::_is_a_skel, 0, 0}, + {"",0,0,0},{"",0,0,0}, + {"shutdown", &POA_ImplementationRepository::ServerObject::shutdown_skel, &POA_ImplementationRepository::_TAO_ServerObject_ThruPOA_Proxy_Impl::shutdown, &POA_ImplementationRepository::_TAO_ServerObject_Direct_Proxy_Impl::shutdown}, + {"",0,0,0}, + {"_component", &POA_ImplementationRepository::ServerObject::_component_skel, 0, 0}, + {"",0,0,0},{"",0,0,0}, + {"_non_existent", &POA_ImplementationRepository::ServerObject::_non_existent_skel, 0, 0}, + {"",0,0,0}, + {"_interface", &POA_ImplementationRepository::ServerObject::_interface_skel, 0, 0}, + }; + + if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH) + { + unsigned int key = hash (str, len); + + if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE) + { + const char *s = wordlist[key].opname_; + + if (*str == *s && !strncmp (str + 1, s + 1, len - 1)) + return &wordlist[key]; + } + } + return 0; +} + +static TAO_ImplementationRepository_ServerObject_Perfect_Hash_OpTable tao_ImplementationRepository_ServerObject_optable; + +// TAO_IDL - Generated from +// be\be_visitor_interface/interceptors_ss.cpp:53 + +#if (TAO_HAS_INTERCEPTORS == 1) + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:74 + +class TAO_ServerRequestInfo_ImplementationRepository_ServerObject_ping : public TAO_ServerRequestInfo +{ +public: + TAO_ServerRequestInfo_ImplementationRepository_ServerObject_ping ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *tao_servant_upcall, + POA_ImplementationRepository::ServerObject *tao_impl + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + virtual Dynamic::ParameterList * arguments ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual Dynamic::ExceptionList * exceptions ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Any * result ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual char * target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Boolean target_is_a ( + const char * id + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + TAO_ServerRequestInfo_ImplementationRepository_ServerObject_ping ( + const TAO_ServerRequestInfo_ImplementationRepository_ServerObject_ping & + ); + + void operator= ( + const TAO_ServerRequestInfo_ImplementationRepository_ServerObject_ping & + ); + +private: + POA_ImplementationRepository::ServerObject *_tao_impl; + +}; + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:438 + +TAO_ServerRequestInfo_ImplementationRepository_ServerObject_ping::TAO_ServerRequestInfo_ImplementationRepository_ServerObject_ping ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *_tao_servant_upcall, + POA_ImplementationRepository::ServerObject *tao_impl + ACE_ENV_ARG_DECL_NOT_USED + ) + : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall), + _tao_impl (tao_impl) +{} + +Dynamic::ParameterList * +TAO_ServerRequestInfo_ImplementationRepository_ServerObject_ping::arguments ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the argument list on demand. + Dynamic::ParameterList *parameter_list = + TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + return parameter_list; +} + +Dynamic::ExceptionList * +TAO_ServerRequestInfo_ImplementationRepository_ServerObject_ping::exceptions ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the exception list on demand. + Dynamic::ExceptionList *exception_list = + TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + return exception_list; +} + +CORBA::Any * +TAO_ServerRequestInfo_ImplementationRepository_ServerObject_ping::result ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the result on demand. + CORBA::Boolean tk_void_any = 1; + CORBA::Any *result_any = + TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + return result_any; +} + +char * +TAO_ServerRequestInfo_ImplementationRepository_ServerObject_ping::target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_NOT_USED + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return + CORBA::string_dup (this->_tao_impl->_interface_repository_id ()); +} + +CORBA::Boolean +TAO_ServerRequestInfo_ImplementationRepository_ServerObject_ping::target_is_a ( + const char * id + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER); +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:74 + +class TAO_ServerRequestInfo_ImplementationRepository_ServerObject_shutdown : public TAO_ServerRequestInfo +{ +public: + TAO_ServerRequestInfo_ImplementationRepository_ServerObject_shutdown ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *tao_servant_upcall, + POA_ImplementationRepository::ServerObject *tao_impl + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + virtual Dynamic::ParameterList * arguments ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual Dynamic::ExceptionList * exceptions ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Any * result ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual char * target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Boolean target_is_a ( + const char * id + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + TAO_ServerRequestInfo_ImplementationRepository_ServerObject_shutdown ( + const TAO_ServerRequestInfo_ImplementationRepository_ServerObject_shutdown & + ); + + void operator= ( + const TAO_ServerRequestInfo_ImplementationRepository_ServerObject_shutdown & + ); + +private: + POA_ImplementationRepository::ServerObject *_tao_impl; + +}; + +// TAO_IDL - Generated from +// be\be_visitor_operation/interceptors_ss.cpp:438 + +TAO_ServerRequestInfo_ImplementationRepository_ServerObject_shutdown::TAO_ServerRequestInfo_ImplementationRepository_ServerObject_shutdown ( + TAO_ServerRequest &_tao_server_request, + TAO::Portable_Server::Servant_Upcall *_tao_servant_upcall, + POA_ImplementationRepository::ServerObject *tao_impl + ACE_ENV_ARG_DECL_NOT_USED + ) + : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall), + _tao_impl (tao_impl) +{} + +Dynamic::ParameterList * +TAO_ServerRequestInfo_ImplementationRepository_ServerObject_shutdown::arguments ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the argument list on demand. + Dynamic::ParameterList *parameter_list = + TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + return parameter_list; +} + +Dynamic::ExceptionList * +TAO_ServerRequestInfo_ImplementationRepository_ServerObject_shutdown::exceptions ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the exception list on demand. + Dynamic::ExceptionList *exception_list = + TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + return exception_list; +} + +CORBA::Any * +TAO_ServerRequestInfo_ImplementationRepository_ServerObject_shutdown::result ( + ACE_ENV_SINGLE_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the result on demand. + CORBA::Boolean tk_void_any = 1; + CORBA::Any *result_any = + TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + return result_any; +} + +char * +TAO_ServerRequestInfo_ImplementationRepository_ServerObject_shutdown::target_most_derived_interface ( + ACE_ENV_SINGLE_ARG_DECL_NOT_USED + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return + CORBA::string_dup (this->_tao_impl->_interface_repository_id ()); +} + +CORBA::Boolean +TAO_ServerRequestInfo_ImplementationRepository_ServerObject_shutdown::target_is_a ( + const char * id + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER); +} + +#endif /* TAO_HAS_INTERCEPTORS */ + +/////////////////////////////////////////////////////////////////////// +// Strategized Proxy Broker Implementation +// + +// TAO_IDL - Generated from +// be\be_visitor_interface/strategized_proxy_broker_ss.cpp:40 + +// Factory function Implementation. +POA_ImplementationRepository::_TAO_ServerObject_Strategized_Proxy_Broker * +POA_ImplementationRepository::_TAO_ServerObject_Strategized_Proxy_Broker::the_TAO_ServerObject_Strategized_Proxy_Broker (void) +{ + static POA_ImplementationRepository::_TAO_ServerObject_Strategized_Proxy_Broker + strategized_proxy_broker; + + return &strategized_proxy_broker; +} + +POA_ImplementationRepository::_TAO_ServerObject_Strategized_Proxy_Broker::_TAO_ServerObject_Strategized_Proxy_Broker (void) +{ +} + +POA_ImplementationRepository::_TAO_ServerObject_Strategized_Proxy_Broker::~_TAO_ServerObject_Strategized_Proxy_Broker (void) +{ +} + +TAO::Collocation_Strategy +POA_ImplementationRepository::_TAO_ServerObject_Strategized_Proxy_Broker::get_strategy ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + TAO::Collocation_Strategy strategy = + TAO_ORB_Core::collocation_strategy (obj ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (TAO::TAO_CS_REMOTE_STRATEGY); + + return strategy; +} + +void +POA_ImplementationRepository::_TAO_ServerObject_Strategized_Proxy_Broker::dispatch ( + CORBA::Object_ptr obj, + CORBA::Object_out forward_obj, + TAO::Argument ** args, + int num_args, + const char * op, + size_t op_len, + TAO::Collocation_Strategy strategy + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::Exception)) +{ + TAO::Portable_Server::Servant_Upcall servant_upcall ( + obj->_stubobj ()->servant_orb_var ()->orb_core () + ); + + TAO_Collocated_Skeleton collocated_skel; + TAO_Abstract_ServantBase *servant = 0; + + if (strategy == TAO::TAO_CS_THRU_POA_STRATEGY) + { + servant_upcall.prepare_for_upcall ( + obj->_stubobj ()->object_key (), + op, + forward_obj + ACE_ENV_ARG_PARAMETER + ); + ACE_CHECK; + + servant_upcall.pre_invoke_collocated_request ( + ACE_ENV_SINGLE_ARG_PARAMETER + ); + ACE_CHECK; + + servant = servant_upcall.servant (); + } + else + { + servant = obj->_servant (); + } + + int status = servant->_find (op, + collocated_skel, + strategy, + op_len); + + if (status == -1) + { + ACE_THROW (CORBA::BAD_OPERATION (TAO::VMCID | 2, CORBA::COMPLETED_NO)); + } + + ACE_TRY + { + collocated_skel (servant, + args, + num_args + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } +#if (TAO_HAS_MINIMUM_CORBA == 0) + ACE_CATCH (PortableServer::ForwardRequest, forward_request) + { + forward_obj = + CORBA::Object::_duplicate (forward_request.forward_reference.in ()); + return; + } +#else + ACE_CATCHANY + { + ACE_UNUSED_ARG (forward_obj); + ACE_RE_THROW; + } +#endif /* TAO_HAS_MINIMUM_CORBA */ + ACE_ENDTRY; + ACE_CHECK; +} + +// +// End Strategized Proxy Broker Implementation +/////////////////////////////////////////////////////////////////////// + +// TAO_IDL - Generated from +// be\be_visitor_interface/interface_ss.cpp:640 + +TAO::Collocation_Proxy_Broker * +ImplementationRepository__TAO_ServerObject_Proxy_Broker_Factory_function (CORBA::Object_ptr) +{ + return + ::POA_ImplementationRepository::_TAO_ServerObject_Strategized_Proxy_Broker::the_TAO_ServerObject_Strategized_Proxy_Broker (); +} + +int +ImplementationRepository__TAO_ServerObject_Proxy_Broker_Factory_Initializer (size_t) +{ + ImplementationRepository__TAO_ServerObject_Proxy_Broker_Factory_function_pointer = + ImplementationRepository__TAO_ServerObject_Proxy_Broker_Factory_function; + + return 0; +} + +static int +ImplementationRepository__TAO_ServerObject_Proxy_Broker_Stub_Factory_Initializer_Scarecrow = + ImplementationRepository__TAO_ServerObject_Proxy_Broker_Factory_Initializer ( + reinterpret_cast< + size_t> ( + ImplementationRepository__TAO_ServerObject_Proxy_Broker_Factory_Initializer + ) + ); + + +/////////////////////////////////////////////////////////////////////// +// ThruPOA Proxy Implementation +// + +// TAO_IDL - Generated from +// be\be_visitor_interface/thru_poa_proxy_impl_ss.cpp:37 + +POA_ImplementationRepository::_TAO_ServerObject_ThruPOA_Proxy_Impl::_TAO_ServerObject_ThruPOA_Proxy_Impl (void) +{} + +// ThruPOA Implementation of the IDL interface methods + +// TAO_IDL - Generated from +// be\be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52 + +void +POA_ImplementationRepository::_TAO_ServerObject_ThruPOA_Proxy_Impl::ping ( + TAO_Abstract_ServantBase *servant, + TAO::Argument **, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + reinterpret_cast< + POA_ImplementationRepository::ServerObject_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/ServerObject:1.0" + ) + )->ping ( + ACE_ENV_SINGLE_ARG_PARAMETER + ); + ACE_CHECK; +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52 + +void +POA_ImplementationRepository::_TAO_ServerObject_ThruPOA_Proxy_Impl::shutdown ( + TAO_Abstract_ServantBase *servant, + TAO::Argument **, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + reinterpret_cast< + POA_ImplementationRepository::ServerObject_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/ServerObject:1.0" + ) + )->shutdown ( + ACE_ENV_SINGLE_ARG_PARAMETER + ); + ACE_CHECK; +} + +// +// End ThruPOA Proxy Implementation +/////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////// +// Direct Proxy Implementation +// + +POA_ImplementationRepository::_TAO_ServerObject_Direct_Proxy_Impl::_TAO_ServerObject_Direct_Proxy_Impl (void) +{} + +// TAO_IDL - Generated from +// be\be_visitor_operation/direct_proxy_impl_ss.cpp:42 + +void +POA_ImplementationRepository::_TAO_ServerObject_Direct_Proxy_Impl::ping ( + TAO_Abstract_ServantBase *servant, + TAO::Argument **, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + reinterpret_cast< + POA_ImplementationRepository::ServerObject_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/ServerObject:1.0" + ) + )->ping ( + ACE_ENV_SINGLE_ARG_PARAMETER + ); + ACE_CHECK; +}// TAO_IDL - Generated from +// be\be_visitor_operation/direct_proxy_impl_ss.cpp:42 + +void +POA_ImplementationRepository::_TAO_ServerObject_Direct_Proxy_Impl::shutdown ( + TAO_Abstract_ServantBase *servant, + TAO::Argument **, + int + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + reinterpret_cast< + POA_ImplementationRepository::ServerObject_ptr> ( + servant->_downcast ( + "IDL:ImplementationRepository/ServerObject:1.0" + ) + )->shutdown ( + ACE_ENV_SINGLE_ARG_PARAMETER + ); + ACE_CHECK; +} + +// +// End Direct Proxy Implementation +/////////////////////////////////////////////////////////////////////// + +// TAO_IDL - Generated from +// be\be_visitor_interface/interface_ss.cpp:97 + +POA_ImplementationRepository::ServerObject::ServerObject (void) +{ + this->optable_ = &tao_ImplementationRepository_ServerObject_optable; +} + +POA_ImplementationRepository::ServerObject::ServerObject (const ServerObject& rhs) + : TAO_Abstract_ServantBase (rhs), + TAO_ServantBase (rhs) +{ +} + +POA_ImplementationRepository::ServerObject::~ServerObject (void) +{ +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_ss.cpp:98 + +void POA_ImplementationRepository::ServerObject::ping_skel ( + TAO_ServerRequest &_tao_server_request, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ) +{ + POA_ImplementationRepository::ServerObject *_tao_impl = + static_cast< + POA_ImplementationRepository::ServerObject *> ( + _tao_servant + ); + _tao_server_request.argument_flag (0); + + +#if (TAO_HAS_INTERCEPTORS == 1) + TAO::Portable_Server::Servant_Upcall *_tao_upcall = + static_cast< + TAO::Portable_Server::Servant_Upcall *> ( + _tao_servant_upcall + ); + + TAO_ServerRequestInterceptor_Adapter _tao_vfr ( + _tao_server_request.orb_core ()->server_request_interceptors (), + _tao_server_request.interceptor_count () + ); + + TAO_ServerRequestInfo_ImplementationRepository_ServerObject_ping _tao_ri ( + _tao_server_request, + _tao_upcall, + _tao_impl + ACE_ENV_ARG_PARAMETER + ); + + ACE_TRY + { + { + TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (), + true /* Copy TSC to RSC */); + + _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (!_tao_vfr.location_forwarded ()) + { +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_impl->ping ( + ACE_ENV_SINGLE_ARG_PARAMETER + ); + TAO_INTERCEPTOR_CHECK; +#if (TAO_HAS_INTERCEPTORS == 1) + } + } + + if (!_tao_vfr.location_forwarded ()) + { + _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL); + _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + } + ACE_CATCHANY + { + _tao_ri.exception (&ACE_ANY_EXCEPTION); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION + || _tao_status == PortableInterceptor::USER_EXCEPTION) + { + ACE_RE_THROW; + } + } + +# if defined (ACE_HAS_EXCEPTIONS) \ + && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS) + ACE_CATCHALL + { + CORBA::UNKNOWN ex; + + _tao_ri.exception (&ex); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION) + ACE_TRY_THROW (ex); + } +# endif /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */ + ACE_ENDTRY; + ACE_CHECK; +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_server_request.init_reply (); + + // In case _tao_servant_upcall is not used in this function + ACE_UNUSED_ARG (_tao_servant_upcall); +} + +// TAO_IDL - Generated from +// be\be_visitor_operation/operation_ss.cpp:98 + +void POA_ImplementationRepository::ServerObject::shutdown_skel ( + TAO_ServerRequest &_tao_server_request, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ) +{ + POA_ImplementationRepository::ServerObject *_tao_impl = + static_cast< + POA_ImplementationRepository::ServerObject *> ( + _tao_servant + ); + _tao_server_request.argument_flag (0); + + +#if (TAO_HAS_INTERCEPTORS == 1) + TAO::Portable_Server::Servant_Upcall *_tao_upcall = + static_cast< + TAO::Portable_Server::Servant_Upcall *> ( + _tao_servant_upcall + ); + + TAO_ServerRequestInterceptor_Adapter _tao_vfr ( + _tao_server_request.orb_core ()->server_request_interceptors (), + _tao_server_request.interceptor_count () + ); + + TAO_ServerRequestInfo_ImplementationRepository_ServerObject_shutdown _tao_ri ( + _tao_server_request, + _tao_upcall, + _tao_impl + ACE_ENV_ARG_PARAMETER + ); + + ACE_TRY + { + { + TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (), + true /* Copy TSC to RSC */); + + _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (!_tao_vfr.location_forwarded ()) + { +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_impl->shutdown ( + ACE_ENV_SINGLE_ARG_PARAMETER + ); + TAO_INTERCEPTOR_CHECK; +#if (TAO_HAS_INTERCEPTORS == 1) + } + } + + if (!_tao_vfr.location_forwarded ()) + { + _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL); + _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + } + ACE_CATCHANY + { + _tao_ri.exception (&ACE_ANY_EXCEPTION); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION + || _tao_status == PortableInterceptor::USER_EXCEPTION) + { + ACE_RE_THROW; + } + } + +# if defined (ACE_HAS_EXCEPTIONS) \ + && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS) + ACE_CATCHALL + { + CORBA::UNKNOWN ex; + + _tao_ri.exception (&ex); + _tao_vfr.send_exception ( + &_tao_ri + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION) + ACE_TRY_THROW (ex); + } +# endif /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */ + ACE_ENDTRY; + ACE_CHECK; +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_server_request.init_reply (); + + // In case _tao_servant_upcall is not used in this function + ACE_UNUSED_ARG (_tao_servant_upcall); +} + +// TAO_IDL - Generated from +// be\be_visitor_interface/interface_ss.cpp:162 + +void POA_ImplementationRepository::ServerObject::_is_a_skel ( + TAO_ServerRequest &_tao_server_request, + void * _tao_servant, + void * /* Servant_Upcall */ + ACE_ENV_ARG_DECL + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + + POA_ImplementationRepository::ServerObject *_tao_impl = + static_cast<POA_ImplementationRepository::ServerObject *> (_tao_servant); + + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + + if (!(_tao_in >> value.out ())) + { + ACE_THROW (CORBA::MARSHAL ()); + } + + _tao_retval = _tao_impl->_is_a (value.in () ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + _tao_server_request.init_reply (); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + + if (!(_tao_out << CORBA::Any::from_boolean (_tao_retval))) + { + ACE_THROW (CORBA::MARSHAL ()); + } +} + +void POA_ImplementationRepository::ServerObject::_non_existent_skel ( + TAO_ServerRequest &_tao_server_request, + void * _tao_servant, + void * /* Servant_Upcall */ + ACE_ENV_ARG_DECL + ) +{ + POA_ImplementationRepository::ServerObject *_tao_impl = + static_cast<POA_ImplementationRepository::ServerObject *> (_tao_servant); + + CORBA::Boolean _tao_retval = + _tao_impl->_non_existent (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + _tao_server_request.init_reply (); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + + if (!(_tao_out << CORBA::Any::from_boolean (_tao_retval))) + { + ACE_THROW (CORBA::MARSHAL ()); + } +} + +void POA_ImplementationRepository::ServerObject::_interface_skel ( + TAO_ServerRequest &_tao_server_request, + void * _tao_servant, + void * /* Servant_Upcall */ + ACE_ENV_ARG_DECL + ) +{ + TAO_IFR_Client_Adapter *_tao_adapter = + ACE_Dynamic_Service<TAO_IFR_Client_Adapter>::instance ( + TAO_ORB_Core::ifr_client_adapter_name () + ); + + if (_tao_adapter == 0) + { + ACE_THROW (CORBA::INTF_REPOS ()); + } + + POA_ImplementationRepository::ServerObject *_tao_impl = + static_cast<POA_ImplementationRepository::ServerObject *> (_tao_servant); + + CORBA::InterfaceDef_ptr _tao_retval = + _tao_impl->_get_interface (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + _tao_server_request.init_reply (); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + + CORBA::Boolean _tao_result = + _tao_adapter->interfacedef_cdr_insert ( + _tao_out, + _tao_retval + ); + + _tao_adapter->dispose (_tao_retval); + + if (_tao_result == 0) + { + ACE_THROW (CORBA::MARSHAL ()); + } +} + +void POA_ImplementationRepository::ServerObject::_component_skel ( + TAO_ServerRequest &_tao_server_request, + void * _tao_object_reference, + void * /* Servant_Upcall */ + ACE_ENV_ARG_DECL + ) +{ + POA_ImplementationRepository::ServerObject *_tao_impl = + static_cast<POA_ImplementationRepository::ServerObject *> (_tao_object_reference); + + CORBA::Object_var _tao_retval = + _tao_impl->_get_component (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + _tao_server_request.init_reply (); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + + if (!(_tao_out << _tao_retval.in ())) + { + ACE_THROW (CORBA::MARSHAL ()); + } +} + +CORBA::Boolean POA_ImplementationRepository::ServerObject::_is_a ( + const char* value + ACE_ENV_ARG_DECL_NOT_USED + ) +{ + return + ( + !ACE_OS::strcmp ( + value, + "IDL:ImplementationRepository/ServerObject:1.0" + ) || + !ACE_OS::strcmp ( + value, + "IDL:omg.org/CORBA/Object:1.0" + ) + ); +} + +void* POA_ImplementationRepository::ServerObject::_downcast ( + const char* logical_type_id + ) +{ + if (ACE_OS::strcmp (logical_type_id, + "IDL:ImplementationRepository/ServerObject:1.0") == 0) + { + return static_cast<POA_ImplementationRepository::ServerObject_ptr> (this); + } + + if (ACE_OS::strcmp (logical_type_id, + "IDL:omg.org/CORBA/Object:1.0") == 0) + { + return static_cast<PortableServer::Servant> (this); + } + + return 0; +} + +const char* POA_ImplementationRepository::ServerObject::_interface_repository_id (void) const +{ + return "IDL:ImplementationRepository/ServerObject:1.0"; +} + +// TAO_IDL - Generated from +// be\be_visitor_interface/interface_ss.cpp:576 + +void POA_ImplementationRepository::ServerObject::_dispatch ( + TAO_ServerRequest &req, + void *servant_upcall + ACE_ENV_ARG_DECL + ) +{ + this->synchronous_upcall_dispatch (req, + servant_upcall, + this + ACE_ENV_ARG_PARAMETER); +} + +// TAO_IDL - Generated from +// be\be_visitor_interface/interface_ss.cpp:527 + +ImplementationRepository::ServerObject * +POA_ImplementationRepository::ServerObject::_this (ACE_ENV_SINGLE_ARG_DECL) +{ + TAO_Stub *stub = this->_create_stub (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + TAO_Stub_Auto_Ptr safe_stub (stub); + CORBA::Object_ptr tmp = CORBA::Object::_nil (); + + CORBA::Boolean _tao_opt_colloc = + stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects (); + + ACE_NEW_RETURN ( + tmp, + CORBA::Object (stub, _tao_opt_colloc, this), + 0 + ); + + CORBA::Object_var obj = tmp; + (void) safe_stub.release (); + + typedef ::ImplementationRepository::ServerObject STUB_SCOPED_NAME; + return + TAO::Narrow_Utils<STUB_SCOPED_NAME>::unchecked_narrow ( + obj.in (), + ImplementationRepository__TAO_ServerObject_Proxy_Broker_Factory_function_pointer + ); +} + +// TAO_IDL - Generated from +// be\be_visitor_root/root.cpp:1683 + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + +#endif /* !ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +#endif /* ifndef */ + diff --git a/TAO/tao/ImR_Client/ServerObjectS.h b/TAO/tao/ImR_Client/ServerObjectS.h new file mode 100644 index 00000000000..5612a1bc713 --- /dev/null +++ b/TAO/tao/ImR_Client/ServerObjectS.h @@ -0,0 +1,334 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// and +// Institute for Software Integrated Systems +// Vanderbilt University +// Nashville, TN +// USA +// http://www.isis.vanderbilt.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +// TAO_IDL - Generated from +// be\be_codegen.cpp:390 + +#ifndef _TAO_IDL_ORIG_SERVEROBJECTS_H_ +#define _TAO_IDL_ORIG_SERVEROBJECTS_H_ + +#include /**/ "ace/pre.h" + +#include "ServerObjectC.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "tao/Collocation_Proxy_Broker.h" +#include "tao/PortableServer/PortableServer.h" +#include "tao/PortableServer/Servant_Base.h" + +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option push -w-rvl -w-rch -w-ccc -w-inl +#endif /* __BORLANDC__ */ + +// TAO_IDL - Generated from +// be\be_visitor_module/module_sh.cpp:49 + +namespace POA_ImplementationRepository +{ + + + // TAO_IDL - Generated from + // be\be_visitor_interface/interface_sh.cpp:87 + + class ServerObject; + typedef ServerObject *ServerObject_ptr; + + class _TAO_ServerObject_ThruPOA_Proxy_Impl; + class _TAO_ServerObject_Direct_Proxy_Impl; + class _TAO_ServerObject_Strategized_Proxy_Broker; + + class TAO_IMR_Client_Export ServerObject + : public virtual PortableServer::ServantBase + { + protected: + ServerObject (void); + + public: + // Useful for template programming. + typedef ::ImplementationRepository::ServerObject _stub_type; + typedef ::ImplementationRepository::ServerObject_ptr _stub_ptr_type; + typedef ::ImplementationRepository::ServerObject_var _stub_var_type; + + ServerObject (const ServerObject& rhs); + virtual ~ServerObject (void); + + virtual CORBA::Boolean _is_a ( + const char* logical_type_id + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + virtual void* _downcast ( + const char* logical_type_id + ); + + static void _is_a_skel ( + TAO_ServerRequest &req, + void *servant, + void *servant_upcall + ACE_ENV_ARG_DECL + ); + + static void _non_existent_skel ( + TAO_ServerRequest &req, + void *servant, + void *servant_upcall + ACE_ENV_ARG_DECL + ); + + static void _interface_skel ( + TAO_ServerRequest &req, + void *servant, + void *servant_upcall + ACE_ENV_ARG_DECL + ); + + static void _component_skel ( + TAO_ServerRequest &req, + void *obj, + void *servant_upcall + ACE_ENV_ARG_DECL + ); + + virtual void _dispatch ( + TAO_ServerRequest &req, + void *_servant_upcall + ACE_ENV_ARG_DECL + ); + + ::ImplementationRepository::ServerObject *_this ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ); + + virtual const char* _interface_repository_id (void) const; + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_sh.cpp:45 + + virtual void ping ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + static void ping_skel ( + TAO_ServerRequest &_tao_req, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ); + + // TAO_IDL - Generated from + // be\be_visitor_operation/operation_sh.cpp:45 + + virtual void shutdown ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + static void shutdown_skel ( + TAO_ServerRequest &_tao_req, + void *_tao_servant, + void *_tao_servant_upcall + ACE_ENV_ARG_DECL + ); + }; + + /////////////////////////////////////////////////////////////////////// + // Strategized Proxy Broker Declaration + // + + // TAO_IDL - Generated from + // be\be_visitor_interface/strategized_proxy_broker_sh.cpp:36 + + class TAO_IMR_Client_Export _TAO_ServerObject_Strategized_Proxy_Broker + : public virtual TAO::Collocation_Proxy_Broker + { + public: + _TAO_ServerObject_Strategized_Proxy_Broker (void); + + virtual ~_TAO_ServerObject_Strategized_Proxy_Broker (void); + + TAO::Collocation_Strategy + get_strategy ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void + dispatch ( + CORBA::Object_ptr obj, + CORBA::Object_out forward_obj, + TAO::Argument ** args, + int num_args, + const char * op, + size_t op_len, + TAO::Collocation_Strategy strategy + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC ((CORBA::Exception)); + + static _TAO_ServerObject_Strategized_Proxy_Broker * + the_TAO_ServerObject_Strategized_Proxy_Broker (void); + }; + + // + // End Strategized Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + + + /////////////////////////////////////////////////////////////////////// + // ThruPOA Proxy Impl. Declaration + // + + // TAO_IDL - Generated from + // be\be_visitor_interface/thru_poa_proxy_impl_sh.cpp:37 + + class TAO_IMR_Client_Export _TAO_ServerObject_ThruPOA_Proxy_Impl + { + public: + _TAO_ServerObject_ThruPOA_Proxy_Impl (void); + + virtual ~_TAO_ServerObject_ThruPOA_Proxy_Impl (void) {} + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + ping ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + shutdown ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + }; + + // + // ThruPOA Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// + + // TAO_IDL - Generated from + // be\be_visitor_interface/direct_proxy_impl_sh.cpp:31 + + /////////////////////////////////////////////////////////////////////// + // Direct Impl. Declaration + // + + class TAO_IMR_Client_Export _TAO_ServerObject_Direct_Proxy_Impl + { + public: + _TAO_ServerObject_Direct_Proxy_Impl (void); + + virtual ~_TAO_ServerObject_Direct_Proxy_Impl (void) {} + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + ping ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + // TAO_IDL - Generated from + // be\be_visitor_operation/proxy_impl_xh.cpp:24 + + static void + shutdown ( + TAO_Abstract_ServantBase *servant, + TAO::Argument ** args, + int num_args + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + }; + + // + // Direct Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// + + + +// TAO_IDL - Generated from +// be\be_visitor_module/module_sh.cpp:80 + +} // module ImplementationRepository + +// TAO_IDL - Generated from +// be\be_codegen.cpp:997 + + +#if defined (__ACE_INLINE__) +#include "ServerObjectS.inl" +#endif /* defined INLINE */ + +#if defined(_MSC_VER) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option pop +#endif /* __BORLANDC__ */ + +#include /**/ "ace/post.h" +#endif /* ifndef */ + diff --git a/TAO/tao/ImR_Client/ServerObjectS.inl b/TAO/tao/ImR_Client/ServerObjectS.inl new file mode 100644 index 00000000000..c944d806c1f --- /dev/null +++ b/TAO/tao/ImR_Client/ServerObjectS.inl @@ -0,0 +1,27 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// and +// Institute for Software Integrated Systems +// Vanderbilt University +// Nashville, TN +// USA +// http://www.isis.vanderbilt.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + diff --git a/TAO/tao/ImR_Client/ServerObject_i.cpp b/TAO/tao/ImR_Client/ServerObject_i.cpp new file mode 100644 index 00000000000..fad07c11dca --- /dev/null +++ b/TAO/tao/ImR_Client/ServerObject_i.cpp @@ -0,0 +1,37 @@ +// $Id$ + +#include "tao/orbconf.h" + +/// +/// ImplRepo related. +/// + +#include "tao/ImR_Client/ServerObject_i.h" + +ServerObject_i::ServerObject_i (CORBA::ORB_ptr orb, + PortableServer::POA_ptr poa) + : orb_ (CORBA::ORB::_duplicate (orb)), + poa_ (PortableServer::POA::_duplicate (poa)) +{ +} + +void +ServerObject_i::ping (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} + +void +ServerObject_i::shutdown (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->orb_->shutdown (0 ACE_ENV_ARG_PARAMETER); + ACE_CHECK; +} + +PortableServer::POA_ptr +ServerObject_i::_default_POA (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) +{ + return PortableServer::POA::_duplicate (this->poa_.in ()); +} + diff --git a/TAO/tao/ImR_Client/ServerObject_i.h b/TAO/tao/ImR_Client/ServerObject_i.h new file mode 100644 index 00000000000..e1266d1e8db --- /dev/null +++ b/TAO/tao/ImR_Client/ServerObject_i.h @@ -0,0 +1,65 @@ +//============================================================================= +/** + * @file ServerObject_i.h + * + * $Id$ + * + * @author Darrell Brunsch and Irfan Pyarali + */ +// =================================================================== + +#ifndef TAO_IMPLREPO_I_H +#define TAO_IMPLREPO_I_H + +#include /**/ "ace/pre.h" + +#include "tao/ORB.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "tao/ImR_Client/ServerObjectS.h" +#include "tao/ImR_Client/imr_client_export.h" + +/** + * @class ServerObject_i + * + * @brief Class for pinging a server. Implementation Repository uses + * this to communicate with the IMR registered servers. + * + * \nosubgrouping + * + **/ +class TAO_IMR_Client_Export ServerObject_i + : public POA_ImplementationRepository::ServerObject, + public PortableServer::RefCountServantBase +{ +public: + /// Constructor. + ServerObject_i (CORBA::ORB_ptr orb, + PortableServer::POA_ptr poa); + + /// Ping method. + void ping (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)); + + /// Shutdown the server. + void shutdown (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)); + + /// Returns the default POA for this servant. + PortableServer::POA_ptr _default_POA (ACE_ENV_SINGLE_ARG_DECL); + +protected: + /// Our ORB. We need this member in case we need to shutdown the + /// server. + CORBA::ORB_var orb_; + + /// POA that we are registered with. + PortableServer::POA_var poa_; +}; + +#include /**/ "ace/post.h" + +#endif /* TAO_IMPLREPO_I_H */ diff --git a/TAO/tao/ImR_Client/TAO_IMR_Client.rc b/TAO/tao/ImR_Client/TAO_IMR_Client.rc new file mode 100644 index 00000000000..64272160de5 --- /dev/null +++ b/TAO/tao/ImR_Client/TAO_IMR_Client.rc @@ -0,0 +1,30 @@ +#include "..\Version.h" + +1 VERSIONINFO + FILEVERSION TAO_MAJOR_VERSION,TAO_MINOR_VERSION,TAO_BETA_VERSION,0 + PRODUCTVERSION TAO_MAJOR_VERSION,TAO_MINOR_VERSION,TAO_BETA_VERSION,0 + FILEFLAGSMASK 0x3fL + FILEFLAGS 0x0L + FILEOS 0x4L + FILETYPE 0x1L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904B0" + BEGIN + VALUE "FileDescription", "IMR_Client\0" + VALUE "FileVersion", TAO_VERSION "\0" + VALUE "InternalName", "TAO_IMR_ClientDLL\0" + VALUE "LegalCopyright", "\0" + VALUE "LegalTrademarks", "\0" + VALUE "OriginalFilename", "TAO_IMR_Client.DLL\0" + VALUE "ProductName", "TAO\0" + VALUE "ProductVersion", TAO_VERSION "\0" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1200 + END +END diff --git a/TAO/tao/ImR_Client/imr_client_export.h b/TAO/tao/ImR_Client/imr_client_export.h new file mode 100644 index 00000000000..be4ed299190 --- /dev/null +++ b/TAO/tao/ImR_Client/imr_client_export.h @@ -0,0 +1,39 @@ +// -*- C++ -*- +// $Id$ +// Definition for Win32 Export directives. +// This file is generated automatically by generate_export_file.pl +// ------------------------------ +#ifndef TAO_IMR_CLIENT_EXPORT_H +#define TAO_IMR_CLIENT_EXPORT_H + +#include "ace/config-all.h" + +#if defined (TAO_AS_STATIC_LIBS) +# if !defined (TAO_IMR_CLIENT_HAS_DLL) +# define TAO_IMR_CLIENT_HAS_DLL 0 +# endif /* ! TAO_IMR_CLIENT_HAS_DLL */ +#else +# if !defined (TAO_IMR_CLIENT_HAS_DLL) +# define TAO_IMR_CLIENT_HAS_DLL 1 +# endif /* ! TAO_IMR_CLIENT_HAS_DLL */ +#endif + +#if defined (TAO_IMR_CLIENT_HAS_DLL) && (TAO_IMR_CLIENT_HAS_DLL == 1) +# if defined (TAO_IMR_CLIENT_BUILD_DLL) +# define TAO_IMR_Client_Export ACE_Proper_Export_Flag +# define TAO_IMR_CLIENT_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T) +# define TAO_IMR_CLIENT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# else /* TAO_IMR_CLIENT_BUILD_DLL */ +# define TAO_IMR_Client_Export ACE_Proper_Import_Flag +# define TAO_IMR_CLIENT_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T) +# define TAO_IMR_CLIENT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# endif /* TAO_IMR_CLIENT_BUILD_DLL */ +#else /* TAO_IMR_CLIENT_HAS_DLL == 1 */ +# define TAO_IMR_Client_Export +# define TAO_IMR_CLIENT_SINGLETON_DECLARATION(T) +# define TAO_IMR_CLIENT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +#endif /* TAO_IMR_CLIENT_HAS_DLL == 1 */ + +#endif /* TAO_IMR_CLIENT_EXPORT_H */ + +// End of auto generated file. |