messengers.cpp

corba 通知服务的源代码

//
//        End Strategized Proxy Broker Implementation
///////////////////////////////////////////////////////////////////////

// TAO_IDL - Generated from
// e:\ace_wrappers\tao\tao_idl\be\be_visitor_interface/interface_ss.cpp:631

TAO::Collocation_Proxy_Broker *
_TAO_Messenger_Proxy_Broker_Factory_function (CORBA::Object_ptr)
{
  return
    ::_TAO_Messenger_Strategized_Proxy_Broker::the_TAO_Messenger_Strategized_Proxy_Broker ();
}

int
_TAO_Messenger_Proxy_Broker_Factory_Initializer (size_t)
{
  _TAO_Messenger_Proxy_Broker_Factory_function_pointer = 
    _TAO_Messenger_Proxy_Broker_Factory_function;
  
  return 0;
}

static int
_TAO_Messenger_Proxy_Broker_Stub_Factory_Initializer_Scarecrow =
  _TAO_Messenger_Proxy_Broker_Factory_Initializer (
      ACE_reinterpret_cast (
          size_t,
          _TAO_Messenger_Proxy_Broker_Factory_Initializer
        )
    );


///////////////////////////////////////////////////////////////////////
//                 ThruPOA Proxy  Implementation
//

// TAO_IDL - Generated from
// e:\ace_wrappers\tao\tao_idl\be\be_visitor_interface/thru_poa_proxy_impl_ss.cpp:37

_TAO_Messenger_ThruPOA_Proxy_Impl::_TAO_Messenger_ThruPOA_Proxy_Impl (void)
{}

// ThruPOA Implementation of the IDL interface methods

// TAO_IDL - Generated from 
// e:\ace_wrappers\tao\tao_idl\be\be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
_TAO_Messenger_ThruPOA_Proxy_Impl::send_message (
    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 () =
    ACE_reinterpret_cast (
        POA_Messenger_ptr,
        servant->_downcast (
            "IDL:Messenger:1.0"
          )
      )->send_message (
          ((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<CORBA::Char *>::inout_arg_val *) args[3])->arg ()
          ACE_ENV_ARG_PARAMETER
        );
  ACE_CHECK;
}

//
//           End ThruPOA Proxy Implementation
///////////////////////////////////////////////////////////////////////

// TAO_IDL - Generated from 
// e:\ace_wrappers\tao\tao_idl\be\be_visitor_interface/interface_ss.cpp:97

POA_Messenger::POA_Messenger (void)
{
  this->optable_ = &tao_Messenger_optable;
}

POA_Messenger::POA_Messenger (const POA_Messenger& rhs)
  : TAO_Abstract_ServantBase (rhs),
    TAO_ServantBase (rhs)
{
}

POA_Messenger::~POA_Messenger (void)
{
}

// TAO_IDL - Generated from 
// e:\ace_wrappers\tao\tao_idl\be\be_visitor_operation/operation_ss.cpp:98

void POA_Messenger::send_message_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_Messenger *_tao_impl =
    ACE_static_cast (
        POA_Messenger *,
        _tao_servant
      );
  CORBA::Boolean _tao_retval = 0;
  CORBA::String_var user_name;
  CORBA::String_var subject;
  CORBA::String_var message;
  
  if (!(
      (_tao_in >> user_name.out ()) &&
      (_tao_in >> subject.out ()) &&
      (_tao_in >> message.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    ACE_static_cast (
        TAO_Object_Adapter::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_Messenger_send_message _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      user_name.in (),
      
      subject.in (),
      
      message.inout ()
    );
  
  ACE_TRY
    {
      {
        TAO_PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                           1  /* 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->send_message (
                  user_name.in (),
                  
                  subject.in (),
                  
                  message.inout ()
                );
            
#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 << message.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 
// e:\ace_wrappers\tao\tao_idl\be\be_visitor_interface/interface_ss.cpp:162

void POA_Messenger::_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_Messenger *_tao_impl =
    (POA_Messenger *) _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_Messenger::_non_existent_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_Messenger *_tao_impl =
    (POA_Messenger *) _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_Messenger::_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_Messenger *_tao_impl =
    (POA_Messenger *) _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_Messenger::_component_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_object_reference,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_Messenger *_tao_impl =
    (POA_Messenger *) _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_Messenger::_is_a (
    const char* value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:Messenger:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
     )
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

void* POA_Messenger::_downcast (
    const char* logical_type_id
  )
{
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:Messenger:1.0") == 0)
    {
      return ACE_static_cast (POA_Messenger_ptr, this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/CORBA/Object:1.0") == 0)
    {
      return ACE_static_cast (PortableServer::Servant, this);
    }
  
  return 0;
}

const char* POA_Messenger::_interface_repository_id (void) const
{
  return "IDL:Messenger:1.0";
}

// TAO_IDL - Generated from
// e:\ace_wrappers\tao\tao_idl\be\be_visitor_interface/interface_ss.cpp:567

void POA_Messenger::_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
// e:\ace_wrappers\tao\tao_idl\be\be_visitor_interface/interface_ss.cpp:509

Messenger *
POA_Messenger::_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 ();
  
  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
    {
      ACE_NEW_RETURN (
          tmp,
          CORBA::Object (stub, 1, this),
          0
        );
    }
  else
    {
      ACE_NEW_RETURN (
          tmp,
          CORBA::Object (stub, 0, this),
          0
        );
    }
  
  CORBA::Object_var obj = tmp;
  (void) safe_stub.release ();
  
  typedef ::Messenger STUB_SCOPED_NAME;
  return
    TAO::Narrow_Utils<STUB_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        _TAO_Messenger_Proxy_Broker_Factory_function_pointer
      );
}

#endif /* ifndef */