TAO/tao/Invocation_Base.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file    Invocation_Base.h
   6  *
   7  *  @author Balachandran Natarajan <bala@dre.vanderbilt.edu>
   8  */
   9 //=============================================================================
  10
  11 #ifndef TAO_INVOCATION_BASE_H
  12 #define TAO_INVOCATION_BASE_H
  13
  14 #include /**/ "ace/pre.h"
  15
  16 #include "tao/Object.h"
  17
  18 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  19 # pragma once
  20 #endif /* ACE_LACKS_PRAGMA_ONCE */
  21
  22 #include "tao/Invocation_Utils.h"
  23 #include "tao/GIOPC.h"
  24
  25 #if TAO_HAS_INTERCEPTORS == 1
  26 #include "tao/Exception.h"
  27 #include "tao/PI_ForwardC.h"
  28 #include "tao/ClientRequestInterceptor_Adapter.h"
  29 #include "tao/ServerRequestInterceptor_Adapter.h"
  30 #endif  /* TAO_HAS_INTERCEPTORS == 1 */
  31
  32 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  33
  34 class TAO_Service_Context;
  35 class TAO_Operation_Details;
  36 class TAO_Stub;
  37
  38 namespace TAO
  39 {
  40   class Invocation_Adapter;
  41
  42   /**
  43    * @class Invocation_Base
  44    *
  45    * @brief The base class for the invocation object
  46    *
  47    * This class is the base of the invocation object hierarchy. This
  48    * hierarchy is classified  based on the type of invocation and the
  49    * mode of invocation. One of the objects from the hierarchy is
  50    * created on the stack for every invocation.
  51    *
  52    * In addition this class encapsulates the essential details that
  53    * are required for PortableInterceptors to function
  54    * correctly. Further this class also provides some helper and
  55    * accessor methods that are used by clients.
  56    */
  57   class TAO_Export Invocation_Base
  58   {
  59   public:
  60     virtual ~Invocation_Base ();
  61
  62     /// Accessor and mutator methods
  63     //@{
  64     TAO_Stub *stub () const;
  65
  66     /// Accessor and mutator methods for forwarded object
  67     /// locations.
  68     /**
  69      * These access methods have to be public so that the
  70      * PortableInterceptor can use them
  71      */
  72     CORBA::Object_ptr forwarded_reference ();
  73     void forwarded_reference (CORBA::Object_ptr o);
  74
  75     /// Accessors for the service context list.
  76     /**
  77      * The service context lists are actually cached
  78      * elsewhere. Providing this accessor helps the PI to access this
  79      * list in both remote and collocated mode.
  80      */
  81     TAO_Service_Context &request_service_context ();
  82     TAO_Service_Context &reply_service_context ();
  83
  84     /// Return the forwarded object location by loosing ownership.
  85     CORBA::Object_ptr steal_forwarded_reference ();
  86
  87     /// Return the effective target of the invocation.
  88     /**
  89      * Please see the PortableInterceptor specification in the CORBA
  90      * spec to understand what effective target means.
  91      */
  92     CORBA::Object_ptr effective_target () const;
  93
  94     /// Return the target object
  95     CORBA::Object_ptr target () const;
  96
  97     /// Does this invocation return a response?
  98     CORBA::Boolean response_expected () const;
  99
 100     /// Accessor of reply_status of the invocation.
 101     GIOP::ReplyStatusType reply_status () const;
 102
 103     /// Mutator of reply_status of the invocation.
 104     void reply_status (GIOP::ReplyStatusType s);
 105
 106     /// The operaton details of the invocation
 107     TAO_Operation_Details &operation_details ();
 108     //@}
 109
 110   protected:
 111     /**
 112      * @param otarget The original target on which this invocation
 113      * was started.
 114      *
 115      * @param target the target on which this invocation is flowing
 116      * ie. the effective target
 117      *
 118      * @param op operation details of the invocation on @a target
 119      *
 120      * @param response_expected flag to indicate whether the
 121      * operation encapsulated by @a op returns a response or not.
 122      */
 123     Invocation_Base (CORBA::Object_ptr otarget,
 124                      CORBA::Object_ptr target,
 125                      TAO_Stub *stub,
 126                      TAO_Operation_Details &op,
 127                      bool response_expected,
 128                      bool request_is_remote);
 129
 130   protected:
 131     /// The operation details on which we are operating on.
 132     TAO_Operation_Details &details_;
 133
 134     /// Forwarded object reference.
 135     CORBA::Object_var forwarded_to_;
 136
 137     /// Is response expected?
 138     bool response_expected_;
 139
 140     /// A GIOP reply status of the invocation.
 141     GIOP::ReplyStatusType reply_status_;
 142
 143   private:
 144     Invocation_Base (const Invocation_Base&);
 145     Invocation_Base & operator= (const Invocation_Base &);
 146
 147   private:
 148     //@{
 149     /**
 150      * The following object reference pointers are *not*
 151      * duplicated. They are cached for portable interceptors, and they
 152      * just live for the lifetime of the request. Hence there is no
 153      * point in duplicating the pointers.
 154      */
 155     /// The original target on which the invocation was started.
 156     CORBA::Object_ptr otarget_;
 157
 158     /// The effective target on which the invocation is on.
 159     CORBA::Object_ptr target_;
 160     //@}
 161
 162     TAO_Stub *stub_;
 163
 164     /// Operations invoked by the
 165     /// PortableInterceptor::ClientRequestInfo object to get details
 166     /// about the operation and related stuff.
 167     //@{
 168 #if TAO_HAS_INTERCEPTORS == 1
 169   public:
 170     /// Return a reference to the number of interceptors pushed on to
 171     /// the current interceptor flow stack.
 172     /**
 173      * @note It is a reference since the Portable Interceptor flow stack
 174      *       code must be able to modify this value and use that value
 175      *       at a later time without being forced to use TSS.
 176      */
 177     size_t &stack_size ();
 178
 179     CORBA::Exception *caught_exception ();
 180
 181     /// Change the exception status.
 182     void exception (CORBA::Exception *exception);
 183
 184     /// Invocation status.
 185     TAO::Invocation_Status invoke_status () const;
 186     /// Mutator to set the invocation status.
 187     void invoke_status (Invocation_Status s);
 188
 189     PortableInterceptor::ReplyStatus pi_reply_status () const;
 190
 191     /// Accessor used to determine if the current invocation is part
 192     /// of a remote request, and if not, it will be considered to be
 193     /// part of a collocated request.
 194     bool is_remote_request() const;
 195
 196   protected:
 197     /// Helper method to invoke send_request interception call to all
 198     /// the registered interceptors.
 199     Invocation_Status send_request_interception ();
 200
 201     /// Helper method to invoke receive_reply interception call to all
 202     /// the registered interceptors.
 203     Invocation_Status receive_reply_interception ();
 204
 205     /// Helper method to invoke receive_other interception call to all
 206     /// the registered interceptors.
 207     Invocation_Status receive_other_interception ();
 208
 209     /// Helper methods to handle interception calls when exceptions
 210     /// are thrown by the PortableInterceptor.
 211     PortableInterceptor::ReplyStatus
 212         handle_any_exception (CORBA::Exception * e);
 213
 214     PortableInterceptor::ReplyStatus handle_all_exception ();
 215
 216   protected:
 217     /// The client requestor adapter
 218     ClientRequestInterceptor_Adapter *cri_adapter_;
 219     ServerRequestInterceptor_Adapter *sri_adapter_;
 220
 221     size_t stack_size_;
 222
 223     TAO::Invocation_Status invoke_status_;
 224
 225   private:
 226     /// Pointer to the caught exception.
 227     CORBA::Exception *caught_exception_;
 228
 229     /// Flag used to distinguish a remote invocation versus a collocated
 230     /// (thru-poa) invocation.
 231     bool const is_remote_request_;
 232 #endif /*TAO_HAS_INTERCEPTORS*/
 233     //@}
 234   };
 235 }
 236
 237 TAO_END_VERSIONED_NAMESPACE_DECL
 238
 239 #if defined (__ACE_INLINE__)
 240 # include "tao/Invocation_Base.inl"
 241 #endif /* __ACE_INLINE__ */
 242
 243 #include /**/ "ace/post.h"
 244
 245 #endif /*TAO_INVOCATION_BASE_H*/