CORBA::Environment Class Reference

Environment. More...

#include <Environment.h>

Collaboration diagram for CORBA::Environment:

[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
static Environment *	_duplicate (Environment *)
	Some static methods that need to be defined in every pseudo object.
static Environment *	_nil (void)
static 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 <ex>.
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.

  : exception_ (0)
  , previous_ (0)
{
}

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_.

  : exception_ (0)
  , previous_ (0)
{
  if (rhs.exception_)
    this->exception_ = rhs.exception_->_tao_duplicate ();
}

CORBA::Environment::~Environment

(

void

)

Destructor, release the exception.

Definition at line 58 of file Environment.cpp.

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

{
  this->clear ();

  // If previous is 0 then this is the first Environment, allocated
  // with the ORB, it shouldn't try to pop because the ORB is beign
  // destroyed also.
  if (this->previous_ != 0)
    TAO_ORB_Core_instance ()->default_environment (this->previous_);
}

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().

  : exception_ (0)
  , previous_ (orb_core->default_environment ())
{
  orb_core->default_environment (this);
}

---

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 33 of file Environment.inl.

References ACE_NEW_RETURN.

{
  if (x == 0)
    {
      return 0;
    }

  CORBA::Environment* ptr = 0;
  ACE_NEW_RETURN (ptr,
                  CORBA::Environment (*x),
                  0);
  return ptr;
}

ACE_INLINE CORBA::Environment_ptr CORBA::Environment::_nil

(

void

)

[static]

Definition at line 49 of file Environment.inl.

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

void CORBA::Environment::clear

(

void

)

Clear the exception.

Definition at line 98 of file Environment.cpp.

References exception_.

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

{
  delete this->exception_;
  this->exception_ = 0;
}

CORBA::Environment & CORBA::Environment::default_environment

(

void

)

[static]

Definition at line 105 of file Environment.cpp.

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

{
  //
  // If we are using native C++ exceptions the user is *not* supposed
  // to clear the environment every time she calls into TAO.  In fact
  // the user is not supposed to use the environment at all!
  //
  // But TAO is using the default environment internally, thus
  // somebody has to clear it. Since TAO passes the environment around
  // this function should only be called when going from the user code
  // into TAO's code.
  //
  // This is not an issue when using the alternative C++ mapping (with
  // the Environment argument) because then the user is supposed to
  // clear the environment before calling into the ORB.
  //
  TAO_ORB_Core_instance ()->default_environment ()->clear ();

  return TAO_default_environment ();;
}

const char * CORBA::Environment::exception_id

(

void

)

const

return the repository ID for the exception.

Definition at line 167 of file Environment.cpp.

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

{
  if (this->exception_ == 0)
    return 0;

  return this->exception_->_rep_id ();
}

int CORBA::Environment::exception_type

(

void

)

const

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

Definition at line 129 of file Environment.cpp.

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

{
  // @@ Carlos, is this stuff that's properly "transformed" for EBCDIC
  //    platforms?!
  // @@ Doug: Yes, they are used to compare against the _id() of the
  //    exception, which should have been mappend to the native
  //    codeset.  Notice the "should" we haven't tried that stuff yet,
  //    and i find it hard to keep track of all the transformations
  //    going on, specially for the TypeCodes that are generated by
  //    the IDL compiler vs. the ones hard-coded in
  //    $TAO_ROOT/tao/Typecode_Constants.cpp

  static char sysex_prefix [] = "IDL:omg.org/CORBA/";
  static char typecode_extra [] = "TypeCode/";

  if (!this->exception_)
    {
      return CORBA::NO_EXCEPTION;
    }

  // All exceptions currently (CORBA 2.0) defined in the CORBA scope
  // are system exceptions ... except for a couple that are related to
  // TypeCodes.

  const char *id = this->exception_->_rep_id ();

  if ((ACE_OS::strncmp (id,
                        sysex_prefix,
                        sizeof sysex_prefix - 1) == 0
       && ACE_OS::strncmp (id + sizeof sysex_prefix - 1,
                           typecode_extra,
                           sizeof typecode_extra - 1) != 0))
    return CORBA::SYSTEM_EXCEPTION;
  else
    return CORBA::USER_EXCEPTION;
}

CORBA::Environment & CORBA::Environment::operator=

(

const Environment &

ACE_TRY_ENV

)

Assingment.

Definition at line 42 of file Environment.cpp.

References exception_, and previous_.

{
  CORBA::Environment tmp (rhs);
  {
    CORBA::Exception *tmp_ex = this->exception_;
    this->exception_ = tmp.exception_;
    tmp.exception_ = tmp_ex;
  }
  {
    CORBA::Environment *tmp_env = this->previous_;
    this->previous_ = rhs.previous_;
    tmp.previous_ = tmp_env;
  }
  return *this;
}

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 179 of file Environment.cpp.

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

{
  if (this->exception_)
    {
      const char *id = this->exception_->_rep_id ();

      ACE_ERROR ((LM_ERROR,
                  ACE_TEXT ("TAO: (%P|%t) EXCEPTION, %s\n"),
                  ACE_TEXT_CHAR_TO_TCHAR (info)));

      CORBA::SystemException *x2 =
        CORBA::SystemException::_downcast (this->exception_);

      if (x2 != 0)
        x2->_tao_print_system_exception ();
      else
        // @@ we can use the exception's typecode to dump all the data
        // held within it ...

        ACE_ERROR ((LM_ERROR,
                    ACE_TEXT ("TAO: (%P|%t) user exception, ID '%s'\n"),
                    ACE_TEXT_CHAR_TO_TCHAR (id)));
    }
  else
    ACE_ERROR ((LM_ERROR,
                ACE_TEXT ("TAO: (%P|%t) no exception, %s\n"), ACE_TEXT_CHAR_TO_TCHAR (info)));
}

---

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 <ex>.

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=().

---

The documentation for this class was generated from the following files:

• Environment.h
• Environment.cpp
• Environment.inl

---