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
252
253
254
255
256
257
258
|
// This may look like C, but it's really -*- C++ -*-
// $Id$
// ============================================================================
//
// = LIBRARY
// TAO
//
// = FILENAME
// Servant_Base.h
//
// = AUTHOR
// Irfan Pyarali
//
// ============================================================================
#ifndef TAO_SERVANT_BASE_H
#define TAO_SERVANT_BASE_H
#include "ace/pre.h"
#include "PortableServerC.h"
#include "tao/Abstract_Servant_Base.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
class TAO_Operation_Table;
class TAO_PortableServer_Export TAO_ServantBase
: public virtual TAO_Abstract_ServantBase
{
// = TITLE
// Base class for skeletons and servants.
//
// = DESCRIPTION
// The POA spec requires that all servants inherit from this
// class.
public:
friend class TAO_POA;
friend class TAO_Object_Adapter;
friend class CORBA_Object;
friend class TAO_Local_ServantBase;
virtual ~TAO_ServantBase (void);
// Destructor.
virtual PortableServer::POA_ptr _default_POA (
CORBA_Environment &ACE_TRY_ENV =
TAO_default_environment ()
);
// Returns the default POA for this servant.
virtual CORBA::Boolean _is_a (const char* logical_type_id,
CORBA_Environment &ACE_TRY_ENV =
TAO_default_environment ());
// Local implementation of the CORBA::Object::_is_a method.
virtual CORBA::Boolean _non_existent (CORBA_Environment &ACE_TRY_ENV =
TAO_default_environment ());
// Default <_non_existent>: always returns false.
virtual CORBA_InterfaceDef_ptr _get_interface (
CORBA_Environment &ACE_TRY_ENV =
TAO_default_environment ()
);
virtual void *_downcast (const char *repository_id) = 0;
// Get the correct vtable.
virtual TAO_Stub *_create_stub (CORBA_Environment &ACE_TRY_ENV);
// This is an auxiliar method for _this() and _narrow().
virtual void _dispatch (TAO_ServerRequest &request,
void *servant_upcall,
CORBA_Environment &ACE_TRY_ENV) = 0;
// Dispatches a request to the object: find the operation, cast the
// type to the most derived type, demarshall all the parameters from
// the request and finally invokes the operation, storing the
// results and out parameters (if any) or the exceptions thrown into
// <request>.
protected:
TAO_ServantBase (void);
// Default constructor, only derived classes can be created.
TAO_ServantBase (const TAO_ServantBase &);
// Copy constructor, protected so no instances can be created.
TAO_ServantBase &operator= (const TAO_ServantBase &);
// assignment operator.
virtual void synchronous_upcall_dispatch (TAO_ServerRequest &req,
void *servant_upcall,
void *derived_this,
CORBA::Environment &ACE_TRY_ENV);
virtual int _find (const char *opname,
TAO_Skeleton &skelfunc,
const unsigned int length = 0);
// Find an operation in the operation table.
virtual int _bind (const char *opname,
const TAO_Skeleton skel_ptr);
// Register a CORBA IDL operation name.
virtual const char *_interface_repository_id (void) const = 0;
// Get this interface's repository id (TAO specific).
protected:
TAO_Operation_Table *optable_;
// The operation table for this servant, it is initialized by the
// most derived class.
};
class TAO_PortableServer_Export TAO_RefCountServantBase
: public virtual TAO_ServantBase
{
// = TITLE
// Reference counting mix-in class.
//
// = DESCRIPTION
// The RefCountServantBase mix-in class overrides the inherited
// _add_ref and _remove_ref functions it inherits from
// ServantBase, implementing them to provide true reference
// counting. An instance of a servant class derived from
// RefCountServantBase initially has a reference count of
// one. Invoking _add_ref on the servant instance increases its
// reference count by one. Invoking _remove_ref on the servant
// instance decreases its reference count by one; if the
// resulting reference count equals zero, _remove_ref invokes
// delete on its this pointer in order to destroy the
// servant. For ORBs that operate in multi-threaded
// environments, the implementations of _add_ref and _remove_ref
// that the RefCountServantBase class provides shall be
// thread-safe.
//
// Like ServantBase, RefCountServantBase supports copy
// construction and the default assignment operation. Copy
// construction always sets the reference count of the new
// servant instance to one. The default assignment
// implementation merely returns *this and does not affect the
// reference count.
public:
~TAO_RefCountServantBase (void);
// Destructor.
virtual void _add_ref (CORBA_Environment &ACE_TRY_ENV =
TAO_default_environment ());
// Increase reference count by one.
virtual void _remove_ref (CORBA_Environment &ACE_TRY_ENV =
TAO_default_environment ());
// Decreases reference count by one; if the resulting reference
// count equals zero, _remove_ref invokes delete on its this pointer
// in order to destroy the servant.
protected:
TAO_RefCountServantBase (void);
// Constructor: initial reference count is one.
TAO_RefCountServantBase (const TAO_RefCountServantBase &);
// Copy Constructor: Always sets the reference count of the new
// servant instance to one.
TAO_RefCountServantBase &operator= (const TAO_RefCountServantBase &);
// The default assignment implementation merely returns *this and
// does not affect the reference count.
private:
ACE_Atomic_Op<TAO_SYNCH_MUTEX, long> ref_count_;
// Reference counter.
};
class TAO_PortableServer_Export TAO_ServantBase_var
{
// = TITLE
// Auto pointer for reference counting servants.
//
// = DESCRIPTION
// For the convenience of automatically managing servant
// reference counts, the PortableServer namespace also provides
// the ServantBase_var class. This class behaves similarly to
// _var classes for object references (see Section 20.3.1).
public:
TAO_ServantBase_var (void);
TAO_ServantBase_var (TAO_ServantBase *p);
TAO_ServantBase_var (const TAO_ServantBase_var &b);
~TAO_ServantBase_var (void);
TAO_ServantBase_var &operator= (TAO_ServantBase *p);
TAO_ServantBase_var &operator= (const TAO_ServantBase_var &b);
TAO_ServantBase *operator-> () const;
TAO_ServantBase *in (void) const;
TAO_ServantBase *&inout (void);
TAO_ServantBase *&out (void);
TAO_ServantBase *_retn (void);
private:
TAO_ServantBase *ptr_;
};
class TAO_PortableServer_Export TAO_Servant_Hash
{
public:
u_long operator () (PortableServer::Servant servant) const;
// Returns hash value.
};
class TAO_PortableServer_Export TAO_Local_ServantBase
: public virtual TAO_ServantBase
{
// = TITLE
// Base class for local servants.
//
// = DESCRIPTION
// This servant does not register with the POA and does not
// produce a valid stub, i.e., object references of this servant
// cannot be exported. The (collocated) stubs of these servants
// will always be direct, i.e., call directly to the servant and
// don't call through the POA since this servant is not
// registered with the POA.
//
protected:
TAO_Stub *_create_stub (CORBA_Environment &ACE_TRY_ENV =
TAO_default_environment ());
// This is an auxiliar method for _this(). Make sure *not* to
// register with the default POA.
void _dispatch (TAO_ServerRequest &request,
void *servant_upcall,
CORBA_Environment &ACE_TRY_ENV);
// Throws CORBA::BAD_OPERATION exception.
};
#if defined (__ACE_INLINE__)
# include "Servant_Base.i"
#endif /* __ACE_INLINE__ */
#include "ace/post.h"
#endif /* TAO_SERVANT_BASE_H */
|
