summaryrefslogtreecommitdiff
path: root/TAO/tao/ORB.h
blob: 9c28220c8ccce6cf6387545a7a96416b2ab72409 (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
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
// -*- C++ -*-

//=============================================================================
/**
 *  @file    ORB.h
 *
 *  $Id$
 *
 *  Header file for CORBA's ORB type.
 *
 *  @author  Copyright 1994-1995 by Sun Microsystems Inc.
 *  @author Douglas C. Schmidt <schmidt@uci.edu>
 */
//=============================================================================

#ifndef TAO_ORB_H
#define TAO_ORB_H

#include "ace/pre.h"

#include "corbafwd.h"

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

#include "Exception.h"
#include "Services.h"
#include "CORBA_String.h"

// IRIX needs this for the throw specs
#include "PolicyC.h"

typedef enum
{
  TAO_SERVICEID_NAMESERVICE,
  TAO_SERVICEID_TRADINGSERVICE,
  TAO_SERVICEID_IMPLREPOSERVICE,
  TAO_SERVICEID_INTERFACEREPOSERVICE,
  TAO_SERVICEID_MCASTSERVER
} TAO_Service_ID;

/// Forward declarations.
class TAO_MProfile;
struct TAO_Dispatch_Context;
class TAO_Client_Strategy_Factory;
class TAO_Server_Strategy_Factory;
class TAO_InputCDR;
class TAO_OutputCDR;
class TAO_Stub;

class TAO_Acceptor_Filter;

#ifdef TAO_HAS_VALUETYPE
class TAO_ValueFactory_Map;
#endif /* TAO_HAS_VALUETYPE */

// ****************************************************************

/**
 * @class CORBA_ORB
 *
 * @brief ORB pseudo-objref.
 *
 * The "ORB" pseudo-object is used in bootstrapping, such as to
 * create object references from strings.  This class is intended
 * to be inherited by others, which will provide some more of the
 * CORBA support.  Implementations of this "CORBA::ORB" class must
 * know how to create stringify/destringify their objrefs, as well
 * as how to marshal and unmarshal them.
 */
class TAO_Export CORBA_ORB
{
public:

  // ORB_Core has special privileges
  friend class TAO_ORB_Core;
  friend TAO_Export TAO_ORB_Core *TAO_ORB_Core_instance (void);

  class TAO_Export InvalidName : public CORBA_UserException
  {
  public:
    InvalidName (void);
    InvalidName (const InvalidName &);
    ~InvalidName (void);
    InvalidName &operator= (const InvalidName &);

    virtual void _raise (void);

    virtual void _tao_encode (TAO_OutputCDR &cdr
                              TAO_ENV_ARG_DECL_NOT_USED) const;
    virtual void _tao_decode (TAO_InputCDR &cdr
                              TAO_ENV_ARG_DECL_NOT_USED);

    /// = TAO extension
    static InvalidName* _downcast (CORBA_Exception *ex);
    static CORBA::Exception *_alloc (void);
  };
  static CORBA::TypeCode_ptr _tc_InvalidName;

  typedef char *ObjectId;
  typedef CORBA::String_var ObjectId_var;
  typedef CORBA::String_out ObjectId_out;
  static CORBA::TypeCode_ptr _tc_ObjectId;

  typedef CORBA_ORB_ObjectIdList ObjectIdList;
  typedef CORBA_ORB_ObjectIdList_var ObjectIdList_var;
  typedef CORBA_ORB_ObjectIdList_out ObjectIdList_out;
  typedef CORBA_ORB_ObjectIdList *ObjectIdList_ptr;
  static CORBA::TypeCode_ptr _tc_ObjectIdList;

  /// Return a duplicate of <{orb}>.  When work with this duplicate is
  /// complete, it should be freed up using <CORBA::release()>.
  static CORBA::ORB_ptr _duplicate (CORBA::ORB_ptr orb);

  /// Returns a pointer to a nil ORB, i.e., an non-existent ORB.  This
  /// can be used for initialization or in comparisons.
  static CORBA::ORB_ptr _nil (void);

  /// Return this ORB's ORBid.
  char * id (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);

  /**
   * Turn a string-ified object reference back into an object pointer.
   * Typically these strings are created using <object_to_string()>,
   * but not necessarily locally.
   */
  CORBA::Object_ptr string_to_object (const char *str
                                      TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  /**
   * Turn an object reference into a string.  Each type of ORB,
   * e.g. an IIOP ORB, must implement this.  This can be used by
   * servers to publish their whereabouts to clients.  The output of
   * this is typically eventually given to <string_to_object()> as an
   * argument.
   */
  char * object_to_string (CORBA::Object_ptr obj
                           TAO_ENV_ARG_DECL_WITH_DEFAULTS);


#ifdef TAO_HAS_VALUETYPE
  // Value factory operations  (CORBA 2.3 ptc/98-10-05 Ch. 4.2 p.4-7)
  CORBA::ValueFactory_ptr register_value_factory (
         const char *repository_id,
         CORBA::ValueFactory_ptr factory
         TAO_ENV_ARG_DECL_WITH_DEFAULTS );
  void unregister_value_factory (const char * repository_id
                                 TAO_ENV_ARG_DECL_WITH_DEFAULTS );
  CORBA::ValueFactory_ptr lookup_value_factory (
         const char *repository_id
         TAO_ENV_ARG_DECL_WITH_DEFAULTS );
#endif /* TAO_HAS_VALUETYPE */

#if (TAO_HAS_MINIMUM_CORBA == 0)

  // Typedefs for CORBA_ORB_RequestSeq,
  // which is an argument of send_multiple_requests_*().
  // See Request.{h,i,cpp} for definitions.
  typedef CORBA_ORB_RequestSeq RequestSeq;
  typedef CORBA_ORB_RequestSeq_var RequestSeq_var;
  typedef CORBA_ORB_RequestSeq_out RequestSeq_out;

  void create_list (CORBA::Long count,
                    CORBA::NVList_ptr &new_list
                    TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  void create_named_value (CORBA::NamedValue_ptr &nmval
                           TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  void create_exception_list (CORBA::ExceptionList_ptr &exclist
                              TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  void create_environment (CORBA::Environment_ptr &new_env
                           TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  // The following are not implemented and just throw
  // CORBA::NO_IMPLEMENT.

  void create_context_list (CORBA::ContextList_ptr &ctxtlist
                            TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  void get_default_context (CORBA::Context_ptr &ctx
                            TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  CORBA::Boolean get_service_information (CORBA::ServiceType service_type,
                                          CORBA::ServiceInformation_out service_information
                                          TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  void send_multiple_requests_oneway (const CORBA_ORB_RequestSeq &req
                                      TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  void send_multiple_requests_deferred (const CORBA_ORB_RequestSeq &req
                                        TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  void get_next_response (CORBA_Request_ptr &req
                          TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  CORBA::Boolean poll_next_response (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);

  /// The ORB TypeCode creation functions.

  CORBA::TypeCode_ptr create_struct_tc (
      const char *id,
      const char *name,
      const CORBA::StructMemberSeq &members
      TAO_ENV_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  CORBA::TypeCode_ptr create_union_tc (
      const char *id,
      const char *name,
      CORBA::TypeCode_ptr discriminator_type,
      const CORBA::UnionMemberSeq &members
      TAO_ENV_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  CORBA::TypeCode_ptr create_enum_tc (
      const char *id,
      const char *name,
      const CORBA::EnumMemberSeq &members
      TAO_ENV_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  CORBA::TypeCode_ptr create_alias_tc (
      const char *id,
      const char *name,
      CORBA::TypeCode_ptr original_type
      TAO_ENV_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  CORBA::TypeCode_ptr create_exception_tc (
      const char *id,
      const char *name,
      const CORBA::StructMemberSeq &members
      TAO_ENV_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  CORBA::TypeCode_ptr create_interface_tc (
      const char *id,
      const char *name
      TAO_ENV_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  CORBA::TypeCode_ptr create_string_tc (
      CORBA::ULong bound
      TAO_ENV_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  CORBA::TypeCode_ptr create_wstring_tc (
      CORBA::ULong bound
      TAO_ENV_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  CORBA::TypeCode_ptr create_fixed_tc (
      CORBA::UShort digits,
      CORBA::UShort scale
      TAO_ENV_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  CORBA::TypeCode_ptr create_sequence_tc (
      CORBA::ULong bound,
      CORBA::TypeCode_ptr element_type
      TAO_ENV_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  CORBA::TypeCode_ptr create_array_tc (
      CORBA::ULong length,
      CORBA::TypeCode_ptr element_type
      TAO_ENV_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  CORBA::TypeCode_ptr create_value_tc (
      const char *id,
      const char *name,
      CORBA::ValueModifier type_modifier,
      CORBA::TypeCode_ptr concrete_base,
      const CORBA::ValueMemberSeq &members
      TAO_ENV_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  CORBA::TypeCode_ptr create_value_box_tc (
      const char *id,
      const char *name,
      CORBA::TypeCode_ptr boxed_type
      TAO_ENV_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  CORBA::TypeCode_ptr create_native_tc (
      const char *id,
      const char *name
      TAO_ENV_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  CORBA::TypeCode_ptr create_recursive_tc (
      const char *id
      TAO_ENV_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  CORBA::TypeCode_ptr create_abstract_interface_tc (
      const char *id,
      const char *name
      TAO_ENV_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));


  CORBA::TypeCode_ptr create_local_interface_tc (
      const char *id,
      const char *ame
      TAO_ENV_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

#endif /* TAO_HAS_MINIMUM_CORBA */

  // = ORB event loop methods.

  /**
   * Instructs the ORB to initialize itself and run its event loop in
   * the current thread, not returning until the ORB has shut down.
   * If an error occurs during initialization or at run-time, a CORBA
   * system exception will be thrown.
   */
  void run (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);

  /**
   * Instructs the ORB to initialize itself and run its event loop in
   * the current thread, not returning until the ORB has shut down or
   * the time value specified through <tv> has expired.  If an error
   * occurs during initialization or at run-time, a CORBA system
   * exception will be thrown.  <tv> is reduced by the amount of time
   * spent in this call.
   **/
  void run (ACE_Time_Value &tv
            TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  /**
   * Instructs the ORB to initialize itself and run its event loop in
   * the current thread, not returning until the ORB has shut down or
   * the time value specified through <tv> has expired.  If an error
   * occurs during initialization or at run-time, a CORBA system
   * exception will be thrown.  <tv> is reduced by the amount of time
   * spent in this call.  If <tv> is 0, it means that the timeout is
   * infinite.  If <tv> is ACE_Time_Value::zero, it specifies to poll
   * and does not block.
   **/
  void run (ACE_Time_Value *tv
            TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  /// Returns an indication of whether the ORB needs to perform some
  /// work.
  CORBA::Boolean work_pending (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);

  /// Returns an indication of whether the ORB needs to perform some work
  /// but will look for work pending for no more than the specified time.
  /// This is useful for implementing an event loop with an idle timeout.
  CORBA::Boolean work_pending (ACE_Time_Value &tv
                               TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  /**
   * This operation performs an implementation-defined unit of work.
   * Note that the default behavior is to block if the unit of work is
   * not present; this behavior can be modified by passing an
   * appropriate <ACE_Time_Value> as described in run().
   **/
  void perform_work (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
  void perform_work (ACE_Time_Value &
                     TAO_ENV_ARG_DECL_WITH_DEFAULTS);
  void perform_work (ACE_Time_Value *
                     TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  /**
   * This operation instructs the ORB to shut down. Shutting down the
   * ORB causes all Object Adapters to be shut down. If
   * <wait_for_completion> parameter is TRUE, this operation blocks
   * until all ORB processing (including request processing and object
   * deactivation or other operations associated with object adapters)
   * has completed.
   */
  void shutdown (CORBA::Boolean wait_for_completion = 0
                 TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  /**
   * Explicitly destroy the ORB, releasing any resources.  Note that
   * TAO *cannot* implicitly release the resources even if you have
   * destroyed all the references to a particular ORB since
   * CORBA::ORB_init() is required to return the same pointer if
   * called with the same ORBid, only after ORB::destroy() is called
   * it may return a new one.
   *
   * The results of multi-threaded applications, trying to destroy ()
   * the ORB in one thread and trying to service a request in another
   * thread are not well defined. TAO does not support such cases.  */
  void destroy (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);

  CORBA_Object_ptr resolve_initial_references (const char *name
                                               TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  /**
   * This method acts as a mini-bootstrapping Naming Service, which is
   * provided by the ORB for certain well-known object references.  TAO
   * supports the "NameService", "TradingService", "RootPOA", "ImplRepo",
   * and "POACurrent" via this method.  The <timeout> value bounds the
   * amount of time the ORB blocks waiting to resolve the service.
   * This is most useful for bootstrapping remote services, such as
   * the "NameService" or "TradingService", that are commonly resolved
   * via multicast.  By default, the value is 0, which means "use the
   * <TAO_DEFAULT_SERVICE_RESOLUTION_TIMEOUT> timeout period".  Note
   * that by using a default value for the <timeout> parameter, TAO
   * will remains compliant with the CORBA
   * <resolve_initial_references> specification.
   */
  CORBA_Object_ptr resolve_initial_references (const char *name,
                                               ACE_Time_Value *timeout
                                               TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  /// Register an object reference with the ORB.
  void register_initial_reference (
      const char * id,
      CORBA::Object_ptr obj
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  /// Returns a sequence of ObjectIds that lists which objects have
  /// references available via the initial references mechanism.
  CORBA_ORB_ObjectIdList_ptr list_initial_services (
              TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);

  CORBA::Policy_ptr create_policy (CORBA::PolicyType type,
                                   const CORBA::Any& val
                                   TAO_ENV_ARG_DECL_WITH_DEFAULTS);

  // ----------------------------------------------------------------
  // = TAO-specific extensions to the CORBA specification.
  // ----------------------------------------------------------------

  /// Resolve the POA.
  CORBA_Object_ptr resolve_root_poa (TAO_ENV_SINGLE_ARG_DECL);

  /// Initialize the ORB globals correctly, i.e., only when they
  /// haven't been initialized yet.
  static void init_orb_globals (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);

  // The function used by tao to handle the "unexpected" exceptions,
  // It raises CORBA::UNKNOWN.
  static void _tao_unexpected_exception (void);

  // Reference counting...
  CORBA::ULong _incr_refcnt (void);
  CORBA::ULong _decr_refcnt (void);

  /// Set the IOR flag.
  /// Get the IOR flag.
  void _use_omg_ior_format (CORBA::Boolean ior);
  CORBA::Boolean _use_omg_ior_format (void);

  /// Set collocation optimization status.
  /// Get collocation optimization status.
  void _optimize_collocation_objects (CORBA::Boolean opt);
  CORBA::Boolean _optimize_collocation_objects (void) const;

  /// Get the ORB core.
  TAO_ORB_Core *orb_core (void) const;

  /**
   * TAO specific extension to get and set the client ID. The client
   * id can be set by the application which would be used by the FT
   * service. As there are no specific interfaces defined in the spec,
   * we have this prorpietary extensions
   */
  const ACE_CString &_tao_ft_client_id (void);
  void _tao_ft_client_id (const char *id);

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

  /// Get the Timeout value
  ACE_Time_Value *get_timeout (void);

protected:
  // We must be created via the <ORB_init> call.
  CORBA_ORB (TAO_ORB_Core *orb_core);
  ~CORBA_ORB (void);

  /// Resolve the POA current.
  CORBA_Object_ptr resolve_poa_current (TAO_ENV_SINGLE_ARG_DECL);

  /// Resolve the Policy Manager for this ORB.
  CORBA_Object_ptr resolve_policy_manager (TAO_ENV_SINGLE_ARG_DECL_NOT_USED);

  /// Resolve the Policy Current for this thread.
  CORBA_Object_ptr resolve_policy_current (TAO_ENV_SINGLE_ARG_DECL_NOT_USED);

private:

  /// Resolve the given service based on the service ID.
  CORBA::Object_ptr resolve_service (TAO_MCAST_SERVICEID service_id
                                    TAO_ENV_ARG_DECL);

  /// Convert an OMG IOR into an object reference.
  CORBA::Object_ptr ior_string_to_object (const char* ior
                                          TAO_ENV_ARG_DECL);

  /// Convert an URL style IOR into an object reference.
  CORBA::Object_ptr url_ior_string_to_object (const char* ior
                                              TAO_ENV_ARG_DECL);

  /// Check if ORB has shutdown.  If it has, throw an exception.
  void check_shutdown (TAO_ENV_SINGLE_ARG_DECL);

  /// Set the timeout value
  void set_timeout (ACE_Time_Value *timeout);

private:
  /// lock required for mutual exclusion between multiple threads.
  TAO_SYNCH_MUTEX lock_;

  /// Maintains a reference count of number of instantiations of the
  /// ORB.
  u_int refcount_;

  /// Count of the number of times that <ORB_init> has been called.
  static int orb_init_count_;
  // This must be protected by <ACE_Static_Object_Lock>.

  /// The ORB_Core that created us....
  TAO_ORB_Core *orb_core_;

#if defined (TAO_HAS_VALUETYPE)
  /// If non-0 then this is the Factory for OBV unmarshaling
  TAO_ValueFactory_Map *valuetype_factory_map_;
#endif /* TAO_HAS_VALUETYPE */

  /// Decides whether to use the URL notation or to use IOR notation.
  CORBA::Boolean use_omg_ior_format_;

  // = NON-PROVIDED METHODS
  CORBA_ORB (const CORBA_ORB &);
  CORBA_ORB &operator= (const CORBA_ORB &);
  
  /// Timeout value
  ACE_Time_Value *timeout_;

};

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

  CORBA_ORB_var &operator= (CORBA::ORB_ptr);
  CORBA_ORB_var &operator= (const CORBA_ORB_var &);
  CORBA::ORB_ptr operator-> (void) const;

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

private:
  CORBA::ORB_ptr ptr_;
};

class TAO_Export CORBA_ORB_out
{
public:
  CORBA_ORB_out (CORBA::ORB_ptr &);
  CORBA_ORB_out (CORBA_ORB_var &);
  CORBA_ORB_out (const CORBA_ORB_out &);
  CORBA_ORB_out &operator= (CORBA_ORB_out &);
  CORBA_ORB_out &operator= (const CORBA_ORB_var &);
  CORBA_ORB_out &operator= (CORBA::ORB_ptr);
  operator CORBA::ORB_ptr &();
  CORBA::ORB_ptr &ptr (void);
  CORBA::ORB_ptr operator-> (void);

private:
  CORBA::ORB_ptr &ptr_;
};

TAO_Export void
operator<<= (CORBA::Any &, const CORBA::ORB::InvalidName &);
TAO_Export void
operator<<= (CORBA::Any &, CORBA::ORB::InvalidName*);
TAO_Export CORBA::Boolean
operator>>= (const CORBA::Any &, CORBA::ORB::InvalidName *&);
TAO_Export CORBA::Boolean
operator<< (TAO_OutputCDR &, const CORBA::ORB::InvalidName &);
TAO_Export CORBA::Boolean
operator>> (TAO_InputCDR &, CORBA::ORB::InvalidName &);


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

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