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
|
// This may look like C, but it's really -*- C++ -*-
// $Id$
// ============================================================================
//
// = LIBRARY
// TAO
//
// = FILENAME
// Environment.h
//
// = DESCRIPTION
// Declare the CORBA_Environment class.
// Note that this header file only requires a few forward
// declarations of CORBA classes, this is *very* important because
// even the ORB needs to know about it; make your changes with care.
// It is also a good idea trying to minimize cross dependencies
// between header files.
//
// = AUTHOR
// Carlos O'Ryan
//
// ============================================================================
#if !defined (TAO_ENVIRONMENT_H)
# define TAO_ENVIRONMENT_H
class CORBA_Exception;
class TAO_ORB_Core;
class TAO_Export CORBA_Environment
{
// = TITLE
// CORBA_Environment
//
// = DESCRIPTION
//
// A CORBA_Environment is a way to automagically ensure that
// exception data is freed -- the "var" class for Exceptions. It
// adds just a bit of convenience function support, helping
// classify exceptions as well as reducing memory leakage.
//
// The thread has a default environment to simplify porting
// between platforms that support native C++ exceptions and those
// that don't. This is a TSS resource (always), but with a twist:
// if the user creates a new environment the old one is "pushed"
// (actually the new one remembers it), eventually the new
// environment destructor pops itself from the stack and we
// recover the old environment.
// This means that if the user create a new environment and
// somebody calls a function using the default one the exception
// will still be received in the environment created by the user.
// The only drawback is that environments life time must nest
// properly, this shouldn't be a problem because environments are
// usually created on the stack, but, the spec allows their
// creation on the heap and/or as class members; we need to
// investigate the tradeoffs and take a decision.
//
public:
// = Initialization and termination methods.
CORBA_Environment (void);
// The default constructor, the environment will hold no
// exceptions.
CORBA_Environment (const CORBA_Environment &env);
// Copy constructor
CORBA_Environment &operator=(const CORBA_Environment& env);
// Assingment
~CORBA_Environment (void);
// Destructor, release the exception.
CORBA_Exception* exception (void) const;
// Return the exception. Caller must call _incr_refcnf() in order
// to keep the ptr.
void exception (CORBA_Exception *ex);
// Set the exception to <ex>, taking a reference on it.
int exception_type (void) const;
// Return if the exception is a user exception or a system
// exception.
const char* exception_id (void) const;
// return the repository ID for the exception
void clear (void);
// Clear the exception.
void print_exception (const char *info,
FILE *f=stdout) const;
// print the exception to output determined by f
// = Obtain a default environment to use with TAO.
static CORBA_Environment &default_environment (void);
private:
friend class TAO_ORB_Core;
CORBA_Environment (TAO_ORB_Core *orb_core);
// Initialize using a well known ORB Core; this is intended for the
// bootstraping of the ORB_Core, not for general consumption.
private:
CORBA_Exception* exception_;
// Pointer to the exception object contained in the environment.
CORBA_Environment* previous_;
// The previous environment on the "default environment stack".
};
#if defined (__ACE_INLINE__)
# include "tao/Environment.i"
#endif /* __ACE_INLINE__ */
#endif /* TAO_EXCEPTION_H */
|
