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