summaryrefslogtreecommitdiff
path: root/TAO/tao/Object.h
blob: c1c99e1d7b132a1f8cb334f2c527ec216151ed0d (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
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
// This may look like C, but it's really -*- C++ -*-

//=============================================================================
/**
 *  @file    Object.h
 *
 *  $Id$
 *
 *   Header file for Win32 interface to CORBA's base "Object" type.
 *
 *   A "Object" is an entity that can be the target of an invocation
 *   using an ORB.  All CORBA objects provide this functionality.
 *   See the CORBA 2.0 specification for details.
 *
 *
 *  @author  Portions Copyright 1994-1995 by Sun Microsystems Inc.
 *  @author  Portions Copyright 1997 by Washington University
 */
//=============================================================================


#ifndef TAO_CORBA_OBJECT_H
#define TAO_CORBA_OBJECT_H
#include "ace/pre.h"

#include "tao/corbafwd.h"
#include "tao/Object_Proxy_Broker.h"

#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */

class TAO_Stub;

class TAO_Abstract_ServantBase;

class TAO_Export CORBA_Object
{
public:
  /// Destructor.
  virtual ~CORBA_Object (void);

  /// Address of this variable used in <_unchecked_narrow>.
  static int _tao_class_id;

  /// Increment the ref count.
  static CORBA_Object_ptr _duplicate (CORBA_Object_ptr obj);

  /// Return a NULL object.
  static CORBA_Object_ptr _nil (void);

  /// No-op it is just here to simplify some templates.
  ACE_INLINE_FOR_GNUC
  static CORBA_Object_ptr _narrow (CORBA_Object_ptr obj
                                   TAO_ENV_ARG_DECL_WITH_DEFAULTS);
  static CORBA_Object_ptr _unchecked_narrow (CORBA_Object_ptr obj
                                             TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  /// Used in the implementation of CORBA::Any
  static void _tao_any_destructor (void*);

  /// Uninlined part of the now-inlined CORBA::is_nil().
  static CORBA::Boolean is_nil_i (CORBA_Object_ptr obj);

  // These calls correspond to over-the-wire operations, or at least
  // do so in many common cases.  The normal implementation assumes a
  // particular simple, efficient, protocol-neutral interface for
  // making such calls, but may be overridden when it appears
  // appropriate.

  /// determine if we are of the type specified by the "logical_type_id"
  virtual CORBA::Boolean _is_a (const char *logical_type_id
                                TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  /// The repository ID for the most derived class, this is an
  /// implementation method and does no remote invocations!
  virtual const char* _interface_repository_id (void) const;

  /// Is this object collocated with the servant?
  virtual CORBA::Boolean _is_collocated (void) const;

  /// Is this a local object?
  virtual CORBA::Boolean _is_local (void) const;

  virtual TAO_Abstract_ServantBase*_servant (void) const;

#if (TAO_HAS_MINIMUM_CORBA == 0)

  virtual CORBA::Boolean _non_existent (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);

  /// This method is deprecated in the CORBA 2.2 spec, we just return 0
  /// every time.
  virtual CORBA::ImplementationDef_ptr _get_implementation (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);


  /// Get info about the object from the Interface Repository.
  virtual CORBA_InterfaceDef_ptr _get_interface (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);


  // DII operations to create a request.
  //
  // The mapping for create_request is split into two forms,
  // corresponding to the two usage styles described in CORBA section
  // 6.2.1.

  virtual void _create_request (CORBA::Context_ptr ctx,
                                const char *operation,
                                CORBA::NVList_ptr arg_list,
                                CORBA::NamedValue_ptr result,
                                CORBA::Request_ptr &request,
                                CORBA::Flags req_flags
                                TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  virtual void _create_request (CORBA::Context_ptr ctx,
                                const char *operation,
                                CORBA::NVList_ptr arg_list,
                                CORBA::NamedValue_ptr result,
                                CORBA::ExceptionList_ptr exclist,
                                CORBA::ContextList_ptr ctxtlist,
                                CORBA::Request_ptr &request,
                                CORBA::Flags req_flags
                                TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  // The default implementation of this method uses the same simple,
  // multi-protocol remote invocation interface as is assumed by the
  // calls above ... that's how it can have a default implementation.

  /// DII operation to create a request.
  virtual CORBA::Request_ptr _request (const char *operation
                                       TAO_ENV_ARG_DECL_WITH_DEFAULTS);

#endif /* TAO_HAS_MINIMUM_CORBA */

#if (TAO_HAS_CORBA_MESSAGING == 1)

  CORBA::Policy_ptr _get_policy (
      CORBA::PolicyType type
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  CORBA::Policy_ptr _get_client_policy (
      CORBA::PolicyType type
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  CORBA::Object_ptr _set_policy_overrides (
      const CORBA::PolicyList & policies,
      CORBA::SetOverrideType set_add
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  CORBA::PolicyList * _get_policy_overrides (
      const CORBA::PolicyTypeSeq & types
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  CORBA::Boolean _validate_connection (
      CORBA::PolicyList_out inconsistent_policies
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


#endif /* TAO_HAS_CORBA_MESSAGING == 1 */

  /**
   * Return a (potentially non-unique) hash value for this object.
   * This method relies on the representation of the object
   * reference's private state.  Since that changes easily (when
   * different ORB protocols are in use) there is no default
   * implementation.
   */
  virtual CORBA::ULong _hash (CORBA::ULong maximum
                              TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  /**
   * Try to determine if this object is the same as <other_obj>.  This
   * method relies on the representation of the object reference's
   * private state.  Since that changes easily (when different ORB
   * protocols are in use) there is no default implementation.
   */
  virtual CORBA::Boolean _is_equivalent (CORBA::Object_ptr other_obj
                                         TAO_ENV_ARG_DECL_WITH_DEFAULTS)
    ACE_THROW_SPEC (());

  /// Return the object key as an out parameter.  Caller should release
  /// return value when finished with it.
  virtual TAO_ObjectKey *_key (TAO_ENV_SINGLE_ARG_DECL);

  /**
   * Return a reference to the object key of profile in-use.
   * If there's no in-use profile, then the program will
   * probably crash.  This method does not create a new copy.
   */
  virtual const TAO_ObjectKey &_object_key (void);

  /// Downcasting this object pointer to some other derived class.
  /// This QueryInterface stuff only work for local object.
  virtual void * _tao_QueryInterface (ptr_arith_t type);

#if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
  typedef CORBA_Object_ptr _ptr_type;
  typedef CORBA_Object_var _var_type;
#endif /* __GNUC__ */
  // Useful for template programming.

  // = Reference count managment.
  /// Increment the reference count.
  virtual void _add_ref (void);

  /// Decrement the reference count.
  virtual void _remove_ref (void);

  // = TAO extensions

  CORBA_Object (TAO_Stub *p = 0,
                CORBA::Boolean collocated = 0,
                TAO_Abstract_ServantBase *servant = 0);


  /// get the underlying stub object
  virtual TAO_Stub *_stubobj (void) const;

  /// Sets the proxy broker.
  virtual void _proxy_broker (TAO_Object_Proxy_Broker *proxy_broker);

  /// Gets the proxy broker.
  virtual TAO_Object_Proxy_Broker *_proxy_broker (void);

protected:
  /// Initializing a local object.
  CORBA_Object (int dummy);

  // = Internal Reference count managment.
  /// Increment the reference count.
  CORBA::ULong _incr_refcnt (void);

  /// Decrement the reference count.
  CORBA::ULong _decr_refcnt (void);

  /// Flag to indicate collocation.  It is 0 except for collocated
  /// objects.
  CORBA::Boolean is_collocated_;

  /// Servant pointer.  It is 0 except for collocated objects.
  TAO_Abstract_ServantBase *servant_;

  /// Specify whether this is a local object or not.
  CORBA::Boolean is_local_;

  /**
   * Pointer to the Proxy Broker i.e. the instance
   * that takes care of getting the right proxy
   * for performing a given call.
   */
  TAO_Object_Proxy_Broker *proxy_broker_;

private:
  /**
   * Pointer to the protocol-specific "object" containing important
   * profiling information regarding this proxy.
   * The protocol proxy is (potentially) shared among several
   * CORBA_Objects
   */
  TAO_Stub *protocol_proxy_;

  /// Number of outstanding references to this object.
  CORBA::ULong refcount_;

  /// Protect the reference count, this is OK because we do no
  /// duplicates or releases on the critical path.
  TAO_SYNCH_MUTEX refcount_lock_;

  // = Unimplemented methods
  CORBA_Object (const CORBA_Object &);
  CORBA_Object &operator = (const CORBA_Object &);
};

class TAO_Export CORBA_Object_var
{
public:
  CORBA_Object_var (void); // default constructor
  CORBA_Object_var (CORBA::Object_ptr);
  CORBA_Object_var (const CORBA_Object_var &); // copy constructor
  ~CORBA_Object_var (void); // destructor

  CORBA_Object_var &operator= (CORBA::Object_ptr);
  CORBA_Object_var &operator= (const CORBA_Object_var &);
  CORBA::Object_ptr operator-> (void) const;

  /// in, inout, out, _retn
  operator const CORBA::Object_ptr &() const;
  operator CORBA::Object_ptr &();
  CORBA::Object_ptr in (void) const;
  CORBA::Object_ptr &inout (void);
  CORBA::Object_ptr &out (void);
  CORBA::Object_ptr _retn (void);
  CORBA::Object_ptr ptr (void) const;

  static CORBA::Object_ptr tao_duplicate (CORBA::Object_ptr);
  static void tao_release (CORBA::Object_ptr);
  static CORBA::Object_ptr tao_nil (void);
  static CORBA::Object_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED);
  static CORBA::Object * tao_upcast (void *);

private:
  CORBA::Object_ptr ptr_;
};

class TAO_Export CORBA_Object_out
{
public:
  CORBA_Object_out (CORBA::Object_ptr &);
  CORBA_Object_out (CORBA_Object_var &);
  CORBA_Object_out (const CORBA_Object_out &);
  CORBA_Object_out &operator= (const CORBA_Object_out &);
  CORBA_Object_out &operator= (const CORBA_Object_var &);
  CORBA_Object_out &operator= (CORBA::Object_ptr);
  operator CORBA::Object_ptr &();
  CORBA::Object_ptr &ptr (void);
  CORBA::Object_ptr operator-> (void);

private:
  CORBA::Object_ptr &ptr_;
};


extern TAO_Export  TAO_Object_Proxy_Broker * (*_TAO_collocation_Object_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  );

// This function pointer is set only when the Portable server library is
// present.

TAO_Export CORBA::Boolean
operator<< (TAO_OutputCDR&, const CORBA_Object*);

TAO_Export CORBA::Boolean
operator>> (TAO_InputCDR&, CORBA_Object*&);

#if defined (__ACE_INLINE__)
# include "tao/Object.i"
#endif /* __ACE_INLINE__ */

#include "ace/post.h"
#endif /* TAO_CORBA_OBJECT_H */