Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages | Search for 

CORBA::Environment Class Reference

Environment. More...

#include <Environment.h>

Collaboration diagram for CORBA::Environment:

Collaboration graph
[legend]
List of all members.

Public Types

typedef CORBA::Environment_ptr _ptr_type
typedef CORBA::Environment_var _var_type
typedef CORBA::Environment_out _out_type

Public Member Functions

 Environment (void)
 Environment (const Environment &ACE_TRY_ENV)
 Copy constructor.

Environment & operator= (const Environment &ACE_TRY_ENV)
 Assingment.

 ~Environment (void)
 Destructor, release the exception.

int exception_type (void) const
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

Static Public Member Functions

Environment * _duplicate (Environment *)
 Some static methods that need to be defined in every pseudo object.

Environment * _nil (void)
CORBA::Environment & default_environment (void)

Public Attributes

CORBA::Exception *exception
void 		const
 Return the contained CORBA::Exception.

void exception CORBA::Exception * ex
 Set the contained CORBA::Exception to .


Private Member Functions

 Environment (TAO_ORB_Core *orb_core)

Private Attributes

CORBA::Exception * exception_
 Pointer to the exception object contained in the environment.

Environment * previous_
 The previous environment on the "default environment stack".

Detailed Description

Environment.

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.

Definition at line 73 of file Environment.h.

Member Typedef Documentation

typedef CORBA::Environment_out CORBA::Environment::_out_type
 

Definition at line 137 of file Environment.h.

typedef CORBA::Environment_ptr CORBA::Environment::_ptr_type
 

Definition at line 135 of file Environment.h.

typedef CORBA::Environment_var CORBA::Environment::_var_type
 

Definition at line 136 of file Environment.h.

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL CORBA::Environment::Environment (  void   ) 
 

The default constructor. The environment will hold no exceptions.

Definition at line 20 of file Environment.cpp. 

00021   : exception_ (0)
00022   , previous_ (0)
00023 {
00024 }

CORBA::Environment::Environment (  const Environment &  ACE_TRY_ENV  ) 
 

Copy constructor.

Definition at line 26 of file Environment.cpp.

References CORBA::Exception::_tao_duplicate(), and exception_. 

00027   : exception_ (0)
00028   , previous_ (0)
00029 {
00030   if (rhs.exception_)
00031     this->exception_ = rhs.exception_->_tao_duplicate ();
00032 }

CORBA::Environment::~Environment (  void   ) 
 

Destructor, release the exception.

Definition at line 58 of file Environment.cpp.

References clear(), TAO_ORB_Core::default_environment(), previous_, and TAO_ORB_Core_instance(). 

00059 {
00060   this->clear ();
00061 
00062   // If previous is 0 then this is the first Environment, allocated
00063   // with the ORB, it shouldn't try to pop because the ORB is beign
00064   // destroyed also.
00065   if (this->previous_ != 0)
00066     TAO_ORB_Core_instance ()->default_environment (this->previous_);
00067 }

CORBA::Environment::Environment (  TAO_ORB_Core *  orb_core  )  [private]
 

Initialize using a well known ORB Core; this is intended for the bootstraping of the ORB_Core, not for general consumption.

Definition at line 34 of file Environment.cpp.

References TAO_ORB_Core::default_environment(). 

00035   : exception_ (0)
00036   , previous_ (orb_core->default_environment ())
00037 {
00038   orb_core->default_environment (this);
00039 }

Member Function Documentation

ACE_INLINE CORBA::Environment * CORBA::Environment::_duplicate (  Environment *   )  [static]
 

Some static methods that need to be defined in every pseudo object.

Definition at line 31 of file Environment.i. 

00032 {
00033   if (x == 0)
00034     {
00035       return 0;
00036     }
00037 
00038   return new CORBA::Environment (*x);
00039 }

ACE_INLINE CORBA::Environment_ptr CORBA::Environment::_nil (  void   )  [static]
 

Definition at line 43 of file Environment.i. 

00044 {
00045   return static_cast <CORBA::Environment_ptr> (0);
00046 }

void CORBA::Environment::clear (  void   ) 
 

Clear the exception.

Definition at line 100 of file Environment.cpp.

References exception_.

Referenced by default_environment(), and ~Environment(). 

00101 {
00102   delete this->exception_;
00103   this->exception_ = 0;
00104 }

CORBA::Environment & CORBA::Environment::default_environment (  void   )  [static]
 

Definition at line 107 of file Environment.cpp.

References clear(), TAO_ORB_Core::default_environment(), TAO_default_environment(), and TAO_ORB_Core_instance(). 

00108 {
00109 #if defined (TAO_HAS_EXCEPTIONS)
00110   //
00111   // If we are using native C++ exceptions the user is *not* supposed
00112   // to clear the environment every time she calls into TAO.  In fact
00113   // the user is not supposed to use the environment at all!
00114   //
00115   // But TAO is using the default environment internally, thus
00116   // somebody has to clear it. Since TAO passes the environment around
00117   // this function should only be called when going from the user code
00118   // into TAO's code.
00119   //
00120   // This is not an issue when using the alternative C++ mapping (with
00121   // the Environment argument) because then the user is supposed to
00122   // clear the environment before calling into the ORB.
00123   //
00124   TAO_ORB_Core_instance ()->default_environment ()->clear ();
00125 #endif /* TAO_HAS_EXCEPTIONS */
00126 
00127   return TAO_default_environment ();;
00128 }

const char * CORBA::Environment::exception_id (  void   )  const
 

return the repository ID for the exception.

Definition at line 171 of file Environment.cpp.

References CORBA::Exception::_rep_id(), and exception_. 

00172 {
00173   if (this->exception_ == 0)
00174     return 0;
00175 
00176   return this->exception_->_rep_id ();
00177 }

int CORBA::Environment::exception_type (  void   )  const
 

Return if the exception is a user exception or a system exception.

Definition at line 133 of file Environment.cpp.

References CORBA::Exception::_rep_id(), exception_, and ACE_OS::strncmp(). 

00134 {
00135   // @@ Carlos, is this stuff that's properly "transformed" for EBCDIC
00136   //    platforms?!
00137   // @@ Doug: Yes, they are used to compare against the _id() of the
00138   //    exception, which should have been mappend to the native
00139   //    codeset.  Notice the "should" we haven't tried that stuff yet,
00140   //    and i find it hard to keep track of all the transformations
00141   //    going on, specially for the TypeCodes that are generated by
00142   //    the IDL compiler vs. the ones hard-coded in
00143   //    $TAO_ROOT/tao/Typecode_Constants.cpp
00144 
00145   static char sysex_prefix [] = "IDL:omg.org/CORBA/";
00146   static char typecode_extra [] = "TypeCode/";
00147 
00148   if (!this->exception_)
00149     {
00150       return CORBA::NO_EXCEPTION;
00151     }
00152 
00153   // All exceptions currently (CORBA 2.0) defined in the CORBA scope
00154   // are system exceptions ... except for a couple that are related to
00155   // TypeCodes.
00156 
00157   const char *id = this->exception_->_rep_id ();
00158 
00159   if ((ACE_OS::strncmp (id,
00160                         sysex_prefix,
00161                         sizeof sysex_prefix - 1) == 0
00162        && ACE_OS::strncmp (id + sizeof sysex_prefix - 1,
00163                            typecode_extra,
00164                            sizeof typecode_extra - 1) != 0))
00165     return CORBA::SYSTEM_EXCEPTION;
00166   else
00167     return CORBA::USER_EXCEPTION;
00168 }

CORBA::Environment & CORBA::Environment::operator= (  const Environment &  ACE_TRY_ENV  ) 
 

Assingment.

Definition at line 42 of file Environment.cpp.

References exception_, and previous_. 

00043 {
00044   CORBA::Environment tmp (rhs);
00045   {
00046     CORBA::Exception *tmp_ex = this->exception_;
00047     this->exception_ = tmp.exception_;
00048     tmp.exception_ = tmp_ex;
00049   }
00050   {
00051     CORBA::Environment *tmp_env = this->previous_;
00052     this->previous_ = rhs.previous_;
00053     tmp.previous_ = tmp_env;
00054   }
00055   return *this;
00056 }

void CORBA::Environment::print_exception (  const char *  info,
FILE *  f = stdout
)  const
 

Print the exception to output determined by f. This function is not CORBA compliant.

Definition at line 183 of file Environment.cpp.

References CORBA::SystemException::_downcast(), CORBA::Exception::_rep_id(), CORBA::SystemException::_tao_print_system_exception(), ACE_DEBUG, ACE_TEXT, ACE_TEXT_CHAR_TO_TCHAR, exception_, and LM_ERROR. 

00185 {
00186   if (this->exception_)
00187     {
00188       const char *id = this->exception_->_rep_id ();
00189 
00190       ACE_DEBUG ((LM_ERROR,
00191                   ACE_TEXT ("TAO: (%P|%t) EXCEPTION, %s\n"),
00192                   ACE_TEXT_CHAR_TO_TCHAR (info)));
00193 
00194       CORBA::SystemException *x2 =
00195         CORBA::SystemException::_downcast (this->exception_);
00196 
00197       if (x2 != 0)
00198         x2->_tao_print_system_exception ();
00199       else
00200         // @@ we can use the exception's typecode to dump all the data
00201         // held within it ...
00202 
00203         ACE_DEBUG ((LM_ERROR,
00204                     ACE_TEXT ("TAO: (%P|%t) user exception, ID '%s'\n"),
00205                     ACE_TEXT_CHAR_TO_TCHAR (id)));
00206     }
00207   else
00208     ACE_DEBUG ((LM_ERROR,
00209                 ACE_TEXT ("TAO: (%P|%t) no exception, %s\n"), ACE_TEXT_CHAR_TO_TCHAR (info)));
00210 }

Member Data Documentation

CORBA::Exception* exception void CORBA::Environment::const
 

Return the contained CORBA::Exception.

CORBA::Environment retains ownership of the exception, this is contrary to the normal memory management rules in the C++ mapping, but actually mandated by the specification:

"C++ Language Mapping" (formal/00-01-02). Section 1.27 Environment (page 1-113)

Definition at line 102 of file Environment.h.

void exception CORBA::Exception* CORBA::Environment::ex
 

Set the contained CORBA::Exception to .

CORBA::Environment assumes ownership of the exception, this is contrary to the normal memory management rules in the C++ mapping, but actually mandated by the specification:

"C++ Language Mapping" (formal/00-01-02). Section 1.27 Environment (page 1-113)

Definition at line 114 of file Environment.h.

CORBA::Exception* CORBA::Environment::exception_ [private]
 

Pointer to the exception object contained in the environment.

Definition at line 147 of file Environment.h.

Referenced by clear(), Environment(), exception_id(), exception_type(), operator=(), and print_exception().

Environment* CORBA::Environment::previous_ [private]
 

The previous environment on the "default environment stack".

Definition at line 150 of file Environment.h.

Referenced by operator=(), and ~Environment().

The documentation for this class was generated from the following files:
Generated on Thu Nov 9 12:24:46 2006 for TAO by doxygen 1.3.6