TAO::PICurrent_Impl Class Reference

Implementation of the PortableInterceptor::Current interface. More...

#include <PICurrent_Impl.h>

Collaboration diagram for TAO::PICurrent_Impl:

[legend]List of all members.

Public Member Functions
	PICurrent_Impl (void)
	Constructor.
	~PICurrent_Impl (void)
	Destructor.
CORBA::Any *	get_slot (PortableInterceptor::SlotId identifier)
void	set_slot (PortableInterceptor::SlotId identifier, const CORBA::Any &data)
	Set information in the slot table at the given SlotId.
void	take_lazy_copy (PICurrent_Impl *p)
	Logically/Lazy (shallow) copy the given object's slot table.
Private Types
typedef ACE_Array_Base< CORBA::Any >	Table
	Typedef for the underyling "slot table.".
Private Member Functions
void	convert_from_lazy_to_real_copy ()
void	set_callback_for_impending_change (PICurrent_Impl *p)
Table &	current_slot_table ()
	PICurrent_Impl (const PICurrent_Impl &)
void	operator= (const PICurrent_Impl &)
Private Attributes
Table	slot_table_
	Array of CORBA::Anys that is the underlying "slot table.".
PICurrent_Impl *	lazy_copy_
PICurrent_Impl *	impending_change_callback_

---

Detailed Description

Implementation of the PortableInterceptor::Current interface.

This class implements both the "request scope current" and the "thread scope current" objects as required by Portable Interceptors.

Definition at line 50 of file PICurrent_Impl.h.

---

Member Typedef Documentation

typedef ACE_Array_Base<CORBA::Any> TAO::PICurrent_Impl::Table [private]

Typedef for the underyling "slot table.".

Definition at line 83 of file PICurrent_Impl.h.

---

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE TAO::PICurrent_Impl::PICurrent_Impl

(

void

)

Constructor.

Definition at line 8 of file PICurrent_Impl.inl.

References PICurrent_Impl().

Referenced by PICurrent_Impl().

  : slot_table_ (),
    lazy_copy_ (0),
    impending_change_callback_ (0)
{
}

ACE_INLINE TAO::PICurrent_Impl::~PICurrent_Impl

(

void

)

Destructor.

Definition at line 16 of file PICurrent_Impl.inl.

References convert_from_lazy_to_real_copy(), impending_change_callback_, lazy_copy_, set_callback_for_impending_change(), and ~PICurrent_Impl().

Referenced by ~PICurrent_Impl().

{
  // Break any existing ties that another PICurrent has with our table
  // since our table will no longer exist once this destructor completes.
  if (0 != this->impending_change_callback_)
    this->impending_change_callback_->convert_from_lazy_to_real_copy ();

  // If we have logically copied another table, ensure it is told about our
  // demise so that it will not call our non-existant
  // convert_from_lazy_to_real_copy() when it changes/destructs.
  if (0 != this->lazy_copy_)
    this->lazy_copy_->set_callback_for_impending_change (0);
}

TAO::PICurrent_Impl::PICurrent_Impl

(

const PICurrent_Impl &

)

[private]

Prevent copying through the copy constructor and the assignment operator.

---

Member Function Documentation

ACE_INLINE void TAO::PICurrent_Impl::convert_from_lazy_to_real_copy

(

)

[private]

Force this object to convert from a logical (referenced) copy, to a physical (or deep, actual) copy.

Definition at line 31 of file PICurrent_Impl.inl.

References convert_from_lazy_to_real_copy(), current_slot_table(), lazy_copy_, set_callback_for_impending_change(), and slot_table_.

Referenced by convert_from_lazy_to_real_copy(), set_slot(), take_lazy_copy(), and ~PICurrent_Impl().

{
  // Make sure we take a physical copy of the existing logical
  // copy of the table before it disappears/changes.
  if (0 != this->lazy_copy_)
    {
      this->slot_table_ = this->lazy_copy_->current_slot_table ();

      // Must tell the old copied PICurrent_Impl that we no
      // longer want to be told when/if it is going to be
      // changed or destroyed.
      this->lazy_copy_->set_callback_for_impending_change (0);
      this->lazy_copy_ = 0;
    }
}

ACE_INLINE TAO::PICurrent_Impl::Table & TAO::PICurrent_Impl::current_slot_table

(

)

[private]

Returns:

Logically copied slot table if available, otherwise underlying slot table.

Definition at line 54 of file PICurrent_Impl.inl.

References current_slot_table(), lazy_copy_, and slot_table_.

Referenced by convert_from_lazy_to_real_copy(), current_slot_table(), get_slot(), and take_lazy_copy().

{
  return (0 == this->lazy_copy_) ?
         this->slot_table_ :
         this->lazy_copy_->current_slot_table ();
}

TAO_BEGIN_VERSIONED_NAMESPACE_DECL CORBA::Any * TAO::PICurrent_Impl::get_slot

(

PortableInterceptor::SlotId

identifier

)

Retrieve information stored in the slot table at the given SlotId.

Definition at line 22 of file PICurrent_Impl.cpp.

References CORBA::SystemException::_tao_minor_code(), ACE_DEBUG, ACE_NEW_THROW_EX, ACE_TEXT, CORBA::COMPLETED_NO, current_slot_table(), get_slot(), LM_DEBUG, ACE_Array_Base< T >::size(), slot_table_, and TAO_debug_level.

Referenced by get_slot(), and TAO::PICurrent::get_slot().

{
  // No need to check validity of SlotId.  It is validated before this
  // method is invoked.

  // The active slot table should never be a lazy copy of itself!
  if ( (0 != this->lazy_copy_)
      && (&this->lazy_copy_->current_slot_table () == &this->slot_table_))
  {
    if (TAO_debug_level > 0)
      ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) Lazy copy of self detected at %N,%l\n")));
    throw ::CORBA::INTERNAL ();
  }

  // Get the slot table that is currently active
  PICurrent_Impl::Table & table = this->current_slot_table ();
  CORBA::Any * any = 0;

  if (identifier < table.size ())
    {
      ACE_NEW_THROW_EX (any,
                        CORBA::Any (table[identifier]), // Make a copy.
                        CORBA::NO_MEMORY (
                          CORBA::SystemException::_tao_minor_code (
                            0,
                            ENOMEM),
                          CORBA::COMPLETED_NO));
    }
  else
    {
      // In accordance with the Portable Interceptor specification,
      // return an Any with a TCKind of tk_null.  A default
      // constructed Any has that TCKind.
      ACE_NEW_THROW_EX (any,
                        CORBA::Any,
                        CORBA::NO_MEMORY (
                          CORBA::SystemException::_tao_minor_code (
                            0,
                            ENOMEM),
                          CORBA::COMPLETED_NO));
    }

  return any;
}

void TAO::PICurrent_Impl::operator=

(

const PICurrent_Impl &

)

[private]

Prevent copying through the copy constructor and the assignment operator.

ACE_INLINE void TAO::PICurrent_Impl::set_callback_for_impending_change

(

PICurrent_Impl *

p

)

[private]

Set the callback PICurrent_Impl object that will be notified of this object's impending destruction or change. Set to 0 to clear. (NOTE Only handles a SINGLE object at at time, does NOT warn previous callback that this has been changed.)

Definition at line 48 of file PICurrent_Impl.inl.

References impending_change_callback_, and set_callback_for_impending_change().

Referenced by convert_from_lazy_to_real_copy(), set_callback_for_impending_change(), take_lazy_copy(), and ~PICurrent_Impl().

{
  this->impending_change_callback_ = (this == p) ? 0 : p;
}

void TAO::PICurrent_Impl::set_slot	(	PortableInterceptor::SlotId	identifier,
		const CORBA::Any &	data
	)

Set information in the slot table at the given SlotId.

Definition at line 68 of file PICurrent_Impl.cpp.

References convert_from_lazy_to_real_copy(), impending_change_callback_, set_slot(), ACE_Array_Base< T >::size(), and slot_table_.

Referenced by set_slot(), and TAO::PICurrent::set_slot().

{
  // No need to check validity of SlotId.  It is validated before this
  // method is invoked.

  // Break any existing ties that another PICurrent has with our table
  // since our table is changing.
  if (0 != this->impending_change_callback_)
    this->impending_change_callback_->convert_from_lazy_to_real_copy ();

  // Ensure that we have a real physical copy of the table before
  // making any changes to it.
  this->convert_from_lazy_to_real_copy ();

  // If the slot table array isn't large enough, then increase its
  // size.  We're guaranteed not to exceed the number of allocated
  // slots for the reason stated above.
  if (identifier >= this->slot_table_.size ()
      && this->slot_table_.size (identifier + 1) != 0)
    throw ::CORBA::INTERNAL ();

  this->slot_table_[identifier] = CORBA::Any (data);
}

void TAO::PICurrent_Impl::take_lazy_copy

(

PICurrent_Impl *

p

)

Logically/Lazy (shallow) copy the given object's slot table.

Definition at line 94 of file PICurrent_Impl.cpp.

References convert_from_lazy_to_real_copy(), current_slot_table(), impending_change_callback_, lazy_copy_, set_callback_for_impending_change(), and take_lazy_copy().

Referenced by take_lazy_copy().

{
  // Check that we are being told to actually change which table we are
  // copying from. (If it is the same as before OR it would ultimately be
  // the same table, we are already correctly setup and we do nothing.)
  if ( (p != this->lazy_copy_)
      && ((0 == p) || (&p->current_slot_table () != &this->current_slot_table ()))
      )
    {
      // Break any existing ties that another PICurrent has with our table
      // since our table is changing.
      if (0 != this->impending_change_callback_)
        this->impending_change_callback_->convert_from_lazy_to_real_copy ();

      // If we have previously logically copied another table, ensure it is
      // told that we are no longer interested in it so that it will not
      // call our conver_from_lazy_to_real_copy() when it changes/destructs.
      if (0 != this->lazy_copy_)
        this->lazy_copy_->set_callback_for_impending_change (0);

      // Are we being asked to copy ourself (or nothing)
      if ((0 == p) || (this == p))
        {
          this->lazy_copy_ = 0; // Use our own physical slot_table_
        }
      else
        {
          this->lazy_copy_ = p;

          // Must tell the newly copied PICurrent_Impl that we want to
          // be told when/if it is going to be changed or destroyed.
          this->lazy_copy_->set_callback_for_impending_change (this);
        }
    }
}

---

Member Data Documentation

PICurrent_Impl* TAO::PICurrent_Impl::impending_change_callback_ [private]

PICurrent_Impl object that will be notified of this object's impending destruction or change to its slot_table_. This is the PICurrent_Impl that has access to our slot_table_ via its lazy_copy_ pointer. As necessary this allows that object's convert_from_lazy_to_real_copy() to be called.

Definition at line 113 of file PICurrent_Impl.h.

Referenced by set_callback_for_impending_change(), set_slot(), take_lazy_copy(), and ~PICurrent_Impl().

PICurrent_Impl* TAO::PICurrent_Impl::lazy_copy_ [private]

Access to logical copy from a PICurrent_Impl in another scope, i.e. either the request scope or the thread scope.

Definition at line 106 of file PICurrent_Impl.h.

Referenced by convert_from_lazy_to_real_copy(), current_slot_table(), take_lazy_copy(), and ~PICurrent_Impl().

Table TAO::PICurrent_Impl::slot_table_ [private]

Array of CORBA::Anys that is the underlying "slot table.".

Definition at line 102 of file PICurrent_Impl.h.

Referenced by convert_from_lazy_to_real_copy(), current_slot_table(), get_slot(), and set_slot().

---

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

• PICurrent_Impl.h
• PICurrent_Impl.cpp
• PICurrent_Impl.inl

---