TAO/tao/Messaging/AMH_Skeletons.cpp

   1 // -*- C++ -*-
   2 #include "tao/Messaging/AMH_Skeletons.h"
   3
   4 #include "tao/AnyTypeCode/TypeCode.h"
   5 #include "tao/AnyTypeCode/DynamicC.h"
   6
   7 #include "tao/PortableServer/Servant_Base.h"
   8 #include "tao/PortableServer/SArg_Traits_T.h"
   9 #include "tao/PortableServer/Basic_SArguments.h"
  10 #include "tao/PortableServer/Special_Basic_SArguments.h"
  11 #include "tao/PortableServer/Fixed_Size_SArgument_T.h"
  12 #include "tao/PortableServer/Var_Size_SArgument_T.h"
  13 #include "tao/PortableServer/Object_SArg_Traits.h"
  14 #include "tao/PortableServer/UB_String_SArguments.h"
  15 #include "tao/PortableServer/get_arg.h"
  16 #include "tao/Object.h"
  17
  18 #include "tao/PortableInterceptor.h"
  19 #include "tao/PortableServer/SUpcall_commands.h"
  20 #include "tao/ORB_Core.h"
  21
  22 #include "tao/TAO_Server_Request.h"
  23
  24 void
  25 _is_a_amh_Upcall_Command::execute ()
  26 {
  27   TAO::SArg_Traits< ::ACE_InputCDR::to_boolean>::ret_arg_type retval =
  28     TAO::Portable_Server::get_ret_arg< ::ACE_InputCDR::to_boolean> (
  29       this->operation_details_,
  30       this->args_);
  31
  32   TAO::SArg_Traits< char *>::in_arg_type arg_1 =
  33     TAO::Portable_Server::get_in_arg< char *> (
  34       this->operation_details_,
  35       this->args_,
  36       1);
  37
  38   retval =
  39     this->servant_-> _is_a (
  40       arg_1);
  41 }
  42
  43 void
  44 TAO_AMH_Skeletons::_is_a_amh_skel (TAO_ServerRequest & server_request,
  45                                   TAO::Portable_Server::Servant_Upcall* TAO_INTERCEPTOR (servant_upcall),
  46                                   TAO_ServantBase *servant)
  47 {
  48 #if TAO_HAS_INTERCEPTORS == 1
  49   static ::CORBA::TypeCode_ptr const * const exceptions = 0;
  50   static ::CORBA::ULong const nexceptions = 0;
  51 #endif /* TAO_HAS_INTERCEPTORS */
  52
  53   TAO::SArg_Traits< ::ACE_InputCDR::to_boolean>::ret_val retval;
  54   TAO::SArg_Traits< char *>::in_arg_val _tao_repository_id;
  55
  56   TAO::Argument * const args[] =
  57     {
  58       &retval,
  59       &_tao_repository_id
  60     };
  61
  62   static size_t const nargs = 2;
  63
  64   _is_a_amh_Upcall_Command command (
  65     servant,
  66     server_request.operation_details (),
  67     args);
  68
  69   TAO::Upcall_Wrapper upcall_wrapper;
  70   upcall_wrapper.upcall (server_request
  71                          , args
  72                          , nargs
  73                          , command
  74 #if TAO_HAS_INTERCEPTORS == 1
  75                          , servant_upcall
  76                          , exceptions
  77                          , nexceptions
  78 #endif  /* TAO_HAS_INTERCEPTORS == 1 */
  79                          );
  80   server_request.tao_send_reply ();
  81 }
  82
  83
  84 #if (TAO_HAS_MINIMUM_CORBA == 0)
  85 void
  86 _non_existent_amh_Upcall_Command::execute ()
  87 {
  88   TAO::SArg_Traits< ::ACE_InputCDR::to_boolean>::ret_arg_type retval =
  89     TAO::Portable_Server::get_ret_arg< ::ACE_InputCDR::to_boolean> (
  90       this->operation_details_,
  91       this->args_);
  92
  93   retval =
  94     this->servant_-> _non_existent ();
  95 }
  96
  97 void TAO_AMH_Skeletons::_non_existent_amh_skel (TAO_ServerRequest & server_request,
  98                                                 TAO::Portable_Server::Servant_Upcall* TAO_INTERCEPTOR (servant_upcall),
  99                                                 TAO_ServantBase *servant)
 100 {
 101 #if TAO_HAS_INTERCEPTORS == 1
 102   static ::CORBA::TypeCode_ptr const * const exceptions = 0;
 103   static ::CORBA::ULong const nexceptions = 0;
 104 #endif /* TAO_HAS_INTERCEPTORS */
 105
 106   TAO::SArg_Traits< ::ACE_InputCDR::to_boolean>::ret_val retval;
 107
 108   TAO::Argument * const args[] =
 109     {
 110       &retval
 111     };
 112
 113   static size_t const nargs = 1;
 114
 115   _non_existent_amh_Upcall_Command command (
 116     servant,
 117     server_request.operation_details (),
 118     args);
 119
 120   TAO::Upcall_Wrapper upcall_wrapper;
 121   upcall_wrapper.upcall (server_request
 122                          , args
 123                          , nargs
 124                          , command
 125 #if TAO_HAS_INTERCEPTORS == 1
 126                          , servant_upcall
 127                          , exceptions
 128                          , nexceptions
 129 #endif  /* TAO_HAS_INTERCEPTORS == 1 */
 130                          );
 131   server_request.tao_send_reply ();
 132 }
 133
 134
 135 # if !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO)
 136 void
 137 TAO_AMH_Skeletons::_interface_amh_skel (TAO_ServerRequest & server_request,
 138                                         TAO::Portable_Server::Servant_Upcall* /* servant_upcall */,
 139                                         TAO_ServantBase *servant)
 140 {
 141   TAO_IFR_Client_Adapter *_tao_adapter =
 142     ACE_Dynamic_Service<TAO_IFR_Client_Adapter>::instance (
 143         TAO_ORB_Core::ifr_client_adapter_name ());
 144
 145   if (!_tao_adapter)
 146     {
 147       throw ::CORBA::INTF_REPOS (::CORBA::OMGVMCID | 1, ::CORBA::COMPLETED_NO);
 148     }
 149
 150   ::CORBA::InterfaceDef_ptr _tao_retval = servant->_get_interface ();
 151   server_request.init_reply ();
 152   TAO_OutputCDR &_tao_out = *server_request.outgoing ();
 153
 154   ::CORBA::Boolean const _tao_result =
 155     _tao_adapter->interfacedef_cdr_insert (_tao_out, _tao_retval);
 156
 157   _tao_adapter->dispose (_tao_retval);
 158
 159   if (!_tao_result)
 160     {
 161       throw ::CORBA::MARSHAL ();
 162     }
 163 }
 164
 165 void
 166 _get_component_amh_Upcall_Command::execute ()
 167 {
 168   TAO::SArg_Traits< ::CORBA::Object>::ret_arg_type retval =
 169     TAO::Portable_Server::get_ret_arg< ::CORBA::Object> (
 170       this->operation_details_,
 171       this->args_);
 172
 173   retval =
 174     this->servant_-> _get_component ();
 175 }
 176
 177 void
 178 TAO_AMH_Skeletons::_component_amh_skel (TAO_ServerRequest & server_request,
 179                                         TAO::Portable_Server::Servant_Upcall* TAO_INTERCEPTOR (servant_upcall),
 180                                         TAO_ServantBase *servant)
 181 {
 182 #if TAO_HAS_INTERCEPTORS == 1
 183   static ::CORBA::TypeCode_ptr const * const exceptions = 0;
 184   static ::CORBA::ULong const nexceptions = 0;
 185 #endif /* TAO_HAS_INTERCEPTORS */
 186
 187   TAO::SArg_Traits< ::CORBA::Object>::ret_val retval;
 188
 189   TAO::Argument * const args[] =
 190     {
 191       &retval
 192     };
 193
 194   static size_t const nargs = 1;
 195
 196   _get_component_amh_Upcall_Command command (
 197     servant,
 198     server_request.operation_details (),
 199     args);
 200
 201   TAO::Upcall_Wrapper upcall_wrapper;
 202   upcall_wrapper.upcall (server_request
 203                          , args
 204                          , nargs
 205                          , command
 206 #if TAO_HAS_INTERCEPTORS == 1
 207                          , servant_upcall
 208                          , exceptions
 209                          , nexceptions
 210 #endif  /* TAO_HAS_INTERCEPTORS == 1 */
 211                          );
 212 }
 213 # endif /* !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO) */
 214
 215
 216 void
 217 _repository_id_amh_Upcall_Command::execute ()
 218 {
 219   TAO::SArg_Traits< char *>::ret_arg_type retval =
 220     TAO::Portable_Server::get_ret_arg< char *> (
 221       this->operation_details_,
 222       this->args_);
 223
 224   retval =
 225     this->servant_-> _repository_id ();
 226 }
 227
 228 void
 229 TAO_AMH_Skeletons::_repository_id_amh_skel (TAO_ServerRequest & server_request,
 230                                             TAO::Portable_Server::Servant_Upcall* TAO_INTERCEPTOR (servant_upcall),
 231                                             TAO_ServantBase *servant)
 232 {
 233 #if TAO_HAS_INTERCEPTORS == 1
 234   static ::CORBA::TypeCode_ptr const * const exceptions = 0;
 235   static ::CORBA::ULong const nexceptions = 0;
 236 #endif /* TAO_HAS_INTERCEPTORS */
 237
 238   TAO::SArg_Traits< char *>::ret_val retval;
 239
 240   TAO::Argument * const args[] =
 241     {
 242       &retval
 243     };
 244
 245   static size_t const nargs = 1;
 246
 247   _repository_id_amh_Upcall_Command command (
 248     servant,
 249     server_request.operation_details (),
 250     args);
 251
 252   TAO::Upcall_Wrapper upcall_wrapper;
 253   upcall_wrapper.upcall (server_request
 254                          , args
 255                          , nargs
 256                          , command
 257 #if TAO_HAS_INTERCEPTORS == 1
 258                          , servant_upcall
 259                          , exceptions
 260                          , nexceptions
 261 #endif  /* TAO_HAS_INTERCEPTORS == 1 */
 262                  );
 263   server_request.tao_send_reply ();
 264 }
 265 #endif /* TAO_HAS_MINIMUM_CORBA */
 266
 267