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
|
// -*- C++ -*-
//=============================================================================
/**
* @file Abstract_Servant_Base.h
*
* $Id$
*
* This files contains the TAO_Abstract_ServantBase, which is used
* as a way to decuple the PortableServer from the TAO Core,
* and make it possible to keep the reference to the servant in
* the CORBA::Object class.
*
* @author Angelo Corsaro <corsaro@cs.wustl.edu>
*/
//=============================================================================
#ifndef TAO_ABSTRACT_SERVANT_BASE_H_
#define TAO_ABSTRACT_SERVANT_BASE_H_
#include /**/ "ace/pre.h"
#include "ace/CORBA_macros.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
#include "tao/TAO_Export.h"
#include "tao/Basic_Types.h"
#include "tao/Collocation_Strategy.h"
#include "tao/CORBA_methods.h"
#include "tao/Pseudo_VarOut_T.h"
class TAO_ServerRequest;
class TAO_Stub;
class TAO_Abstract_ServantBase;
namespace CORBA
{
class InterfaceDef;
typedef InterfaceDef *InterfaceDef_ptr;
class Environment;
class Object;
typedef Object *Object_ptr;
typedef TAO_Pseudo_Var_T<Object> Object_var;
typedef TAO_Pseudo_Out_T<Object, Object_var> Object_out;
}
namespace TAO
{
class Argument;
}
typedef void (*TAO_Skeleton)(
TAO_ServerRequest &,
void *,
void *
#if !defined (TAO_HAS_EXCEPTIONS) || defined (ACE_ENV_BKWD_COMPAT)
, CORBA::Environment &
#endif
);
typedef void (*TAO_Collocated_Skeleton)(
TAO_Abstract_ServantBase *,
TAO::Argument **,
int
#if !defined (TAO_HAS_EXCEPTIONS) || defined (ACE_ENV_BKWD_COMPAT)
, CORBA::Environment &
#endif
);
class TAO_Export TAO_Abstract_ServantBase
{
public:
/// Destructor
virtual ~TAO_Abstract_ServantBase (void);
/// Local implementation of the CORBA::Object::_is_a method.
virtual CORBA::Boolean _is_a (const char* logical_type_id
ACE_ENV_ARG_DECL) = 0;
/// Default <_non_existent>: always returns false.
virtual CORBA::Boolean _non_existent (
ACE_ENV_SINGLE_ARG_DECL) = 0;
/// Query the Interface Repository.
virtual CORBA::InterfaceDef_ptr _get_interface (
ACE_ENV_SINGLE_ARG_DECL
) = 0;
/// Default <_get_component>: always returns nil.
virtual CORBA::Object_ptr _get_component (
ACE_ENV_SINGLE_ARG_DECL) = 0;
//@{
/**
* @name Reference Counting Hooks
*
* Reference counting hooks are no-ops by default.
*/
virtual void _add_ref (ACE_ENV_SINGLE_ARG_DECL);
virtual void _remove_ref (ACE_ENV_SINGLE_ARG_DECL);
//@}
/// Get the correct vtable.
virtual void *_downcast (const char *repository_id) = 0;
/// This is an auxiliary method for _this() and _narrow().
virtual TAO_Stub *_create_stub (ACE_ENV_SINGLE_ARG_DECL) = 0;
/// Find an operation in the operation table and return a
/// TAO_Skeleton which can be used to make upcalls
virtual int _find (const char *opname,
TAO_Skeleton &skelfunc,
const unsigned int length = 0) = 0;
/// Find an operation in the operation table and return a
/// TAO_Collocated_Skeleton which can be used to make upcalls onto
/// collocated servants.
virtual int _find (const char *opname,
TAO_Collocated_Skeleton &skelfunc,
TAO::Collocation_Strategy s,
const unsigned int length = 0) = 0;
protected:
/// Default constructor, only derived classes can be created.
TAO_Abstract_ServantBase (void);
/// Copy constructor, protected so no instances can be created.
TAO_Abstract_ServantBase (const TAO_Abstract_ServantBase &);
/// assignment operator.
TAO_Abstract_ServantBase &operator= (const TAO_Abstract_ServantBase &);
/// 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 @a request.
*/
virtual void _dispatch (TAO_ServerRequest &request,
void *servant_upcall
ACE_ENV_ARG_DECL) = 0;
virtual void synchronous_upcall_dispatch (TAO_ServerRequest &req,
void *servant_upcall,
void *derived_this
ACE_ENV_ARG_DECL) = 0;
/*
/// Register a CORBA IDL operation name.
virtual int _bind (const char *opname,
const TAO_Skeleton skel_ptr) = 0;
*/
/// Get this interface's repository id (TAO specific).
virtual const char *_interface_repository_id (void) const = 0;
};
#include /**/ "ace/post.h"
#endif /* TAO_ABSTRACT_SERVANT_BASE_H_ */
|
