TAO_CEC_ProxyPushSupplier Class Reference

ProxyPushSupplier. More...

#include <CEC_ProxyPushSupplier.h>

Collaboration diagram for TAO_CEC_ProxyPushSupplier:

[legend]List of all members.

Public Types
typedef CosEventChannelAdmin::ProxyPushSupplier_ptr	_ptr_type
typedef CosEventChannelAdmin::ProxyPushSupplier_var	_var_type
Public Member Functions
	TAO_CEC_ProxyPushSupplier (TAO_CEC_EventChannel *event_channel, const ACE_Time_Value &timeout)
	constructor...
virtual	~TAO_CEC_ProxyPushSupplier (void)
	destructor...
virtual void	activate (CosEventChannelAdmin::ProxyPushSupplier_ptr &)
	Activate in the POA.
virtual void	deactivate (void)
	Deactivate from the POA.
CORBA::Boolean	is_connected (void) const
	Return 0 if no consumer is connected...
CosEventComm::PushConsumer_ptr	consumer (void) const
virtual void	shutdown (void)
	The event channel is shutting down.
virtual void	push (const CORBA::Any &event)
	Internal methods to push an event to each consumer.
virtual void	push_nocopy (CORBA::Any &event)
void	push_to_consumer (const CORBA::Any &event)
	Pushes to the consumer, verifies that it is connected.
void	reactive_push_to_consumer (const CORBA::Any &event)
CORBA::Boolean	consumer_non_existent (CORBA::Boolean_out disconnected)
virtual void	connect_push_consumer (CosEventComm::PushConsumer_ptr push_consumer)
virtual void	disconnect_push_supplier (void)
CORBA::ULong	_incr_refcnt (void)
	Increment and decrement the reference count.
CORBA::ULong	_decr_refcnt (void)
virtual PortableServer::POA_ptr	_default_POA (void)
virtual void	_add_ref (void)
virtual void	_remove_ref (void)
Protected Member Functions
void	consumer (CosEventComm::PushConsumer_ptr consumer)
void	consumer_i (CosEventComm::PushConsumer_ptr consumer)
CORBA::Boolean	is_connected_i (void) const
	The private version (without locking) of is_connected().
void	cleanup_i (void)
	Release the child and the consumer.
CosEventComm::PushConsumer_ptr	apply_policy (CosEventComm::PushConsumer_ptr c)
CORBA::Object_ptr	apply_policy_obj (CORBA::Object_ptr c)
Private Attributes
TAO_CEC_EventChannel *	event_channel_
	The Event Channel that owns this object.
ACE_Time_Value	timeout_
ACE_Lock *	lock_
	The locking strategy.
CORBA::ULong	refcount_
	The reference count.
CosEventComm::PushConsumer_var	consumer_
CosEventComm::PushConsumer_var	nopolicy_consumer_
	The consumer without any policies applied.
PortableServer::POA_var	default_POA_
	Store the default POA.

---

Detailed Description

ProxyPushSupplier.

Implement the CosEventChannelAdmin::ProxyPushSupplier interface, remember that this class is used to communicate with a PushConsumer, so, in effect, this is the ambassador for a consumer inside the event channel. = MEMORY MANAGMENT It does not assume ownership of the TAO_CEC_Dispatching object. It makes a copy of the ConsumerQOS and the consumer object reference. = LOCKING Locking is strategized, the event channel acts as a factory for the locking strategies.

Definition at line 58 of file CEC_ProxyPushSupplier.h.

---

Member Typedef Documentation

typedef CosEventChannelAdmin::ProxyPushSupplier_ptr TAO_CEC_ProxyPushSupplier::_ptr_type

Definition at line 61 of file CEC_ProxyPushSupplier.h.

typedef CosEventChannelAdmin::ProxyPushSupplier_var TAO_CEC_ProxyPushSupplier::_var_type

Definition at line 62 of file CEC_ProxyPushSupplier.h.

---

Constructor & Destructor Documentation

TAO_CEC_ProxyPushSupplier::TAO_CEC_ProxyPushSupplier	(	TAO_CEC_EventChannel *	event_channel,
		const ACE_Time_Value &	timeout
	)

constructor...

Definition at line 39 of file CEC_ProxyPushSupplier.cpp.

  : event_channel_ (ec),
    timeout_ (timeout),
    refcount_ (1)
{
#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
  typed_event_channel_ = 0;
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */

  this->lock_ =
    this->event_channel_->create_supplier_lock ();

  this->default_POA_ =
    this->event_channel_->supplier_poa ();

  this->event_channel_->get_servant_retry_map ().bind (this, 0);
}

TAO_CEC_ProxyPushSupplier::~TAO_CEC_ProxyPushSupplier

(

void

)

[virtual]

destructor...

Definition at line 79 of file CEC_ProxyPushSupplier.cpp.

References TAO_CEC_EventChannel::destroy_supplier_lock(), event_channel_, and TAO_CEC_EventChannel::get_servant_retry_map().

{
#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
  if (this->is_typed_ec () )
    {
      this->typed_event_channel_->get_servant_retry_map ().unbind (this);
      this->typed_event_channel_->destroy_supplier_lock (this->lock_);
    }
  else
    {
      this->event_channel_->get_servant_retry_map ().unbind (this);
      this->event_channel_->destroy_supplier_lock (this->lock_);
    }
#else
  this->event_channel_->get_servant_retry_map ().unbind (this);
  this->event_channel_->destroy_supplier_lock (this->lock_);
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */
}

---

Member Function Documentation

void TAO_CEC_ProxyPushSupplier::_add_ref

(

void

)

[virtual]

Definition at line 890 of file CEC_ProxyPushSupplier.cpp.

References _incr_refcnt().

{
  this->_incr_refcnt ();
}

CORBA::ULong TAO_CEC_ProxyPushSupplier::_decr_refcnt

(

void

)

Definition at line 303 of file CEC_ProxyPushSupplier.cpp.

References ACE_GUARD_RETURN, TAO_CEC_EventChannel::destroy_proxy(), event_channel_, and refcount_.

Referenced by _remove_ref(), and TAO_CEC_Push_Command::~TAO_CEC_Push_Command().

{
  {
    ACE_GUARD_RETURN (ACE_Lock, ace_mon, *this->lock_, 0);
    --this->refcount_;
    if (this->refcount_ != 0)
      return this->refcount_;
  }

  // Notify the event channel
#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
  if (this->is_typed_ec () )
    {
      this->typed_event_channel_->destroy_proxy (this);
    }
  else
    {
      this->event_channel_->destroy_proxy (this);
    }
#else
  this->event_channel_->destroy_proxy (this);
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */
  return 0;
}

PortableServer::POA_ptr TAO_CEC_ProxyPushSupplier::_default_POA

(

void

)

[virtual]

Definition at line 884 of file CEC_ProxyPushSupplier.cpp.

Referenced by deactivate().

{
  return PortableServer::POA::_duplicate (this->default_POA_.in ());
}

CORBA::ULong TAO_CEC_ProxyPushSupplier::_incr_refcnt

(

void

)

Increment and decrement the reference count.

Definition at line 296 of file CEC_ProxyPushSupplier.cpp.

References ACE_GUARD_RETURN, and refcount_.

Referenced by _add_ref(), and TAO_CEC_Push_Command::TAO_CEC_Push_Command().

{
  ACE_GUARD_RETURN (ACE_Lock, ace_mon, *this->lock_, 0);
  return this->refcount_++;
}

void TAO_CEC_ProxyPushSupplier::_remove_ref

(

void

)

[virtual]

Definition at line 896 of file CEC_ProxyPushSupplier.cpp.

References _decr_refcnt().

{
  this->_decr_refcnt ();
}

void TAO_CEC_ProxyPushSupplier::activate

(

CosEventChannelAdmin::ProxyPushSupplier_ptr &

)

[virtual]

Activate in the POA.

Definition at line 99 of file CEC_ProxyPushSupplier.cpp.

{
  CosEventChannelAdmin::ProxyPushSupplier_var result;
  try
    {
      result = this->_this ();
    }
  catch (const CORBA::Exception&)
    {
      result = CosEventChannelAdmin::ProxyPushSupplier::_nil ();
    }
  activated_proxy = result._retn ();
}

CosEventComm::PushConsumer_ptr TAO_CEC_ProxyPushSupplier::apply_policy

(

CosEventComm::PushConsumer_ptr

c

)

[protected]

Assigns the parameter to both consumer_ and nopolicy_consumer_, and applies policies (when appropriate) to consumer_.

Definition at line 485 of file CEC_ProxyPushSupplier.cpp.

References apply_policy_obj(), TAO_Pseudo_Var_T< T >::in(), and nopolicy_consumer_.

Referenced by connect_push_consumer().

{
  this->nopolicy_consumer_ = CosEventComm::PushConsumer::_duplicate (pre);
  CORBA::Object_var post_obj = apply_policy_obj (pre);
  CosEventComm::PushConsumer_var post =
    CosEventComm::PushConsumer::_narrow (post_obj.in ());
  return post._retn ();
}

CORBA::Object_ptr TAO_CEC_ProxyPushSupplier::apply_policy_obj

(

CORBA::Object_ptr

c

)

[protected]

Definition at line 455 of file CEC_ProxyPushSupplier.cpp.

References CORBA::Object::_duplicate(), TAO_Pseudo_Var_T< T >::_retn(), CORBA::Object::_set_policy_overrides(), event_channel_, and ACE_Time_Value::zero.

Referenced by apply_policy(), and connect_push_consumer().

{
#if defined (TAO_HAS_CORBA_MESSAGING) && TAO_HAS_CORBA_MESSAGING != 0
  CORBA::Object_var post = CORBA::Object::_duplicate (pre);
  if (this->timeout_ > ACE_Time_Value::zero)
    {
      CORBA::PolicyList policy_list;
      policy_list.length (1);
      if (this->typed_event_channel_)
        {
          policy_list[0] = this->typed_event_channel_->
            create_roundtrip_timeout_policy (this->timeout_);
        }
      else
        {
          policy_list[0] = this->event_channel_->
            create_roundtrip_timeout_policy (this->timeout_);
        }
      post = pre->_set_policy_overrides (policy_list, CORBA::ADD_OVERRIDE);

      policy_list[0]->destroy ();
      policy_list.length (0);
    }
  return post._retn ();
#else
  return CORBA::Object::_duplicate (pre);
#endif /* TAO_HAS_CORBA_MESSAGING */
}

void TAO_CEC_ProxyPushSupplier::cleanup_i

(

void

)

[protected]

Release the child and the consumer.

Definition at line 285 of file CEC_ProxyPushSupplier.cpp.

References consumer_.

Referenced by connect_push_consumer(), and disconnect_push_supplier().

{
  this->consumer_ =
    CosEventComm::PushConsumer::_nil ();
#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
  this->typed_consumer_ =
    CosTypedEventComm::TypedPushConsumer::_nil ();
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */
}

void TAO_CEC_ProxyPushSupplier::connect_push_consumer

(

CosEventComm::PushConsumer_ptr

push_consumer

)

[virtual]

Definition at line 329 of file CEC_ProxyPushSupplier.cpp.

References CORBA::Object::_duplicate(), ACE_DEBUG, ACE_GUARD_THROW_EX, ACE_TEXT(), apply_policy(), apply_policy_obj(), cleanup_i(), TAO_CEC_EventChannel::connected(), consumer_, event_channel_, TAO_Pseudo_Var_T< T >::in(), CORBA::is_nil(), LM_DEBUG, TAO_CEC_EventChannel::reconnected(), TAO_CEC_Unlock, and TAO_debug_level.

{
  // Nil PushConsumers are illegal
  if (CORBA::is_nil (push_consumer))
    throw CORBA::BAD_PARAM ();

  {

#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
    // Check if we have a typed event channel
    if (this->is_typed_ec () )
      {
        if (TAO_debug_level >= 10)
          {
            ACE_DEBUG ((LM_DEBUG,
                        ACE_TEXT ("***** connect_push_consumer, ")
                        ACE_TEXT ("Event channel is typed *****\n")));
          }

        // Temporary for the TypedPushConsumer and it's Typed interface,
        // declared and obtained before the Guard to avoid deadlock during the
        // _is_a (during _narrow) and get_typed_consumer invocations.
        // They are eventually assigned onto this object inside the Guard.
        CosTypedEventComm::TypedPushConsumer_var local_typed_consumer =
          CosTypedEventComm::TypedPushConsumer::_narrow (push_consumer);

        // Obtain the typed object interface from the consumer
        CORBA::Object_var local_typed_consumer_obj =
          CORBA::Object::_duplicate (local_typed_consumer->get_typed_consumer () );

        {
          ACE_GUARD_THROW_EX (
              ACE_Lock, ace_mon, *this->lock_,
              CORBA::INTERNAL ());
          // @@ CosEventChannelAdmin::EventChannel::SYNCHRONIZATION_ERROR ());

          if (this->is_connected_i ())
            {
              if (this->typed_event_channel_->consumer_reconnect () == 0)
                throw CosEventChannelAdmin::AlreadyConnected ();

              // Re-connections are allowed....
              this->cleanup_i ();

              this->typed_consumer_ = apply_policy (local_typed_consumer.in () );

              TAO_CEC_Unlock reverse_lock (*this->lock_);

              {
                ACE_GUARD_THROW_EX (
                    TAO_CEC_Unlock, ace_mon, reverse_lock,
                    CORBA::INTERNAL ());
                // @@ CosEventChannelAdmin::EventChannel::SYNCHRONIZATION_ERROR ());

                this->typed_event_channel_->reconnected (this);
              }
              return;

            }

          this->typed_consumer_ = apply_policy (local_typed_consumer.in () );

          // Store the typed object interface from the consumer
          this->typed_consumer_obj_ =
            apply_policy_obj (local_typed_consumer_obj.in () );
        }

        // Notify the event channel...
        this->typed_event_channel_->connected (this);

      } /* this->is_typed_ec */
    else
      {
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */

        if (TAO_debug_level >= 10)
          {
            ACE_DEBUG ((LM_DEBUG,
                        ACE_TEXT ("***** connect_push_consumer, ")
                        ACE_TEXT ("Event channel is un-typed *****\n")));
          }

        {

    ACE_GUARD_THROW_EX (
        ACE_Lock, ace_mon, *this->lock_,
        CORBA::INTERNAL ());
    // @@ CosEventChannelAdmin::EventChannel::SYNCHRONIZATION_ERROR ());

    if (this->is_connected_i ())
      {
        if (this->event_channel_->consumer_reconnect () == 0)
          throw CosEventChannelAdmin::AlreadyConnected ();

        // Re-connections are allowed....
        this->cleanup_i ();

        this->consumer_ = apply_policy (push_consumer);

        TAO_CEC_Unlock reverse_lock (*this->lock_);

        {
          ACE_GUARD_THROW_EX (
              TAO_CEC_Unlock, ace_mon, reverse_lock,
              CORBA::INTERNAL ());
          // @@ CosEventChannelAdmin::EventChannel::SYNCHRONIZATION_ERROR ());

          this->event_channel_->reconnected (this);
        }
        return;
      }

    this->consumer_ = apply_policy (push_consumer);
  }

  // Notify the event channel...
  this->event_channel_->connected (this);

#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
      } /* ! this->is_typed_ec */
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */
  }
}

ACE_INLINE void TAO_CEC_ProxyPushSupplier::consumer

(

CosEventComm::PushConsumer_ptr

consumer

)

[protected]

Set the consumer, used by some implementations to change the policies used when invoking operations on the consumer.

Definition at line 66 of file CEC_ProxyPushSupplier.inl.

References ACE_GUARD, and consumer_i().

{
  ACE_GUARD (ACE_Lock, ace_mon, *this->lock_);

  this->consumer_i (consumer);
}

ACE_INLINE CosEventComm::PushConsumer_ptr TAO_CEC_ProxyPushSupplier::consumer

(

void

)

const

Return the consumer object reference. It returns nil() if it has not connected yet. NOTE: This method does not return a new reference!!! Doing so will increase the locking overhead on the critical path.

Definition at line 33 of file CEC_ProxyPushSupplier.inl.

References ACE_GUARD_RETURN, and consumer_.

Referenced by consumer_non_existent(), disconnect_push_supplier(), push_to_consumer(), reactive_push_to_consumer(), and shutdown().

{
  ACE_GUARD_RETURN (ACE_Lock, ace_mon, *this->lock_, 0);

#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
  if (this->is_typed_ec ())
  {
    return this->typed_consumer_.in ();
  }
  else
  {
    return this->consumer_.in ();
  }
#else
  return this->consumer_.in ();
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */
}

ACE_INLINE void TAO_CEC_ProxyPushSupplier::consumer_i

(

CosEventComm::PushConsumer_ptr

consumer

)

[protected]

Definition at line 52 of file CEC_ProxyPushSupplier.inl.

References consumer_.

Referenced by consumer().

{
  this->consumer_ = consumer;
}

CORBA::Boolean TAO_CEC_ProxyPushSupplier::consumer_non_existent

(

CORBA::Boolean_out

disconnected

)

Invoke the _non_existent() pseudo-operation on the consumer. If it is disconnected then it returns true and sets the <disconnected> flag.

Definition at line 837 of file CEC_ProxyPushSupplier.cpp.

References CORBA::Object::_duplicate(), ACE_GUARD_THROW_EX, and consumer().

Referenced by TAO_CEC_Ping_Push_Consumer::work().

{
  CORBA::Object_var consumer;
  {
    ACE_GUARD_THROW_EX (
        ACE_Lock, ace_mon, *this->lock_,
        CORBA::INTERNAL ());

    disconnected = 0;
    if (this->is_connected_i () == 0)
      {
        disconnected = 1;
        return 0;
      }

#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
    if (this->is_typed_ec () )
      {
        if (CORBA::is_nil (this->nopolicy_typed_consumer_.in ()))
          {
            return 0;
          }
        consumer = CORBA::Object::_duplicate
          (this->nopolicy_typed_consumer_.in ());
      }
    else
      {
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */
    if (CORBA::is_nil (this->nopolicy_consumer_.in ()))
      {
        return 0;
      }
    consumer = CORBA::Object::_duplicate (this->nopolicy_consumer_.in ());
#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
      } /* ! this->is_typed_ec */
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */
  }

#if (TAO_HAS_MINIMUM_CORBA == 0)
  return consumer->_non_existent ();
#else
  return 0;
#endif /* TAO_HAS_MINIMUM_CORBA */
}

void TAO_CEC_ProxyPushSupplier::deactivate

(

void

)

[virtual]

Deactivate from the POA.

Definition at line 115 of file CEC_ProxyPushSupplier.cpp.

References _default_POA().

Referenced by shutdown().

{
  try
    {
      PortableServer::POA_var poa =
        this->_default_POA ();
      PortableServer::ObjectId_var id =
        poa->servant_to_id (this);
      poa->deactivate_object (id.in ());
    }
  catch (const CORBA::Exception&)
    {
      // Exceptions here should not be propagated.  They usually
      // indicate that an object is beign disconnected twice, or some
      // race condition, but not a fault that the user needs to know
      // about.
    }
}

void TAO_CEC_ProxyPushSupplier::disconnect_push_supplier

(

void

)

[virtual]

Definition at line 509 of file CEC_ProxyPushSupplier.cpp.

References CORBA::Exception::_tao_print_exception(), ACE_GUARD_THROW_EX, cleanup_i(), consumer(), consumer_, TAO_CEC_EventChannel::disconnected(), and event_channel_.

Referenced by TAO_CEC_Reactive_ConsumerControl::consumer_not_exist(), and TAO_CEC_Reactive_ConsumerControl::system_exception().

{
  CosEventComm::PushConsumer_var consumer;
#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
  CosTypedEventComm::TypedPushConsumer_var typed_consumer;
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */

  {
    ACE_GUARD_THROW_EX (
        ACE_Lock, ace_mon, *this->lock_,
        CORBA::INTERNAL ());
    // @@ CosEventChannelAdmin::EventChannel::SYNCHRONIZATION_ERROR ());

    if (this->is_connected_i () == 0)
      throw CORBA::BAD_INV_ORDER ();

#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
    if (this->is_typed_ec () )
      {
        typed_consumer = this->typed_consumer_._retn ();
      }
    else
      {
        consumer = this->consumer_._retn ();
      }
#else
    consumer = this->consumer_._retn ();
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */

    this->cleanup_i ();
  }

  // Notify the event channel....
#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
  if (this->is_typed_ec () )
    {
      this->typed_event_channel_->disconnected (this);
    }
  else
    {
      this->event_channel_->disconnected (this);
    }
#else
  this->event_channel_->disconnected (this);
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */

  // Disconnect callbacks
#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
  if (this->is_typed_ec () )
    {
      if (this->typed_event_channel_->disconnect_callbacks ())
        {
          try
            {
              typed_consumer->disconnect_push_consumer ();
            }
          catch (const CORBA::Exception& ex)
            {
              // Ignore exceptions, we must isolate other clients from
              // problems on this one.
              ex._tao_print_exception (
                "ProxySupplier::disconnect_push_supplier");
            }
        }
    } /* this->is_typed_ec */
  else
    {
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */

  if (this->event_channel_->disconnect_callbacks ())
    {
      try
        {
          consumer->disconnect_push_consumer ();
        }
      catch (const CORBA::Exception& ex)
        {
          // Ignore exceptions, we must isolate other clients from
          // problems on this one.
          ex._tao_print_exception ("ProxySupplier::disconnect_push_supplier");
        }
    }

#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
    } /* ! this->is_typed_ec */
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */
}

ACE_INLINE CORBA::Boolean TAO_CEC_ProxyPushSupplier::is_connected

(

void

)

const

Return 0 if no consumer is connected...

Definition at line 25 of file CEC_ProxyPushSupplier.inl.

References ACE_GUARD_RETURN, and is_connected_i().

{
  ACE_GUARD_RETURN (ACE_Lock, ace_mon, *this->lock_, 0);

  return this->is_connected_i ();
}

TAO_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE CORBA::Boolean TAO_CEC_ProxyPushSupplier::is_connected_i

(

void

)

const [protected]

The private version (without locking) of is_connected().

Definition at line 8 of file CEC_ProxyPushSupplier.inl.

References CORBA::is_nil().

Referenced by is_connected().

{
#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
  if (this->is_typed_ec ())
  {
    return !CORBA::is_nil (this->typed_consumer_.in ());
  }
  else
  {
  return !CORBA::is_nil (this->consumer_.in ());
  }
#else
  return !CORBA::is_nil (this->consumer_.in ());
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */
}

void TAO_CEC_ProxyPushSupplier::push

(

const CORBA::Any &

event

)

[virtual]

Internal methods to push an event to each consumer.

Definition at line 206 of file CEC_ProxyPushSupplier.cpp.

References ACE_GUARD, TAO_CEC_EventChannel::dispatching(), event_channel_, TAO_CEC_Dispatching::push(), and TAO_CEC_Unlock.

Referenced by TAO_CEC_Propagate_Event_Push::work().

{
  Destroy_Guard auto_destroy (this->refcount_,
                              this->event_channel_,
                              this);

  {
    ACE_GUARD (ACE_Lock, ace_mon, *this->lock_);

    if (this->is_connected_i () == 0)
      return;

    TAO_ESF_RefCount_Guard<CORBA::ULong> cnt_mon (this->refcount_);

    {
      TAO_CEC_Unlock reverse_lock (*this->lock_);

      ACE_GUARD (TAO_CEC_Unlock, ace_mon, reverse_lock);
      this->event_channel_->dispatching ()->push (this,
                                                  event);
    }
  }
}

void TAO_CEC_ProxyPushSupplier::push_nocopy

(

CORBA::Any &

event

)

[virtual]

Definition at line 260 of file CEC_ProxyPushSupplier.cpp.

References ACE_GUARD, TAO_CEC_EventChannel::dispatching(), event_channel_, TAO_CEC_Dispatching::push_nocopy(), and TAO_CEC_Unlock.

{
  Destroy_Guard auto_destroy (this->refcount_,
                              this->event_channel_,
                              this);

  {
    ACE_GUARD (ACE_Lock, ace_mon, *this->lock_);

    if (this->is_connected_i () == 0)
      return;

    TAO_ESF_RefCount_Guard<CORBA::ULong> cnt_mon (this->refcount_);

    {
      TAO_CEC_Unlock reverse_lock (*this->lock_);

      ACE_GUARD (TAO_CEC_Unlock, ace_mon, reverse_lock);
      this->event_channel_->dispatching ()->push_nocopy (this,
                                                         event);
    }
  }
}

void TAO_CEC_ProxyPushSupplier::push_to_consumer

(

const CORBA::Any &

event

)

Pushes to the consumer, verifies that it is connected.

Definition at line 598 of file CEC_ProxyPushSupplier.cpp.

References ACE_GUARD_THROW_EX, consumer(), TAO_CEC_EventChannel::consumer_control(), event_channel_, and TAO_CEC_ConsumerControl::successful_transmission().

Referenced by TAO_CEC_Push_Command::execute().

{
  CosEventComm::PushConsumer_var consumer;
  {
    ACE_GUARD_THROW_EX (
            ACE_Lock, ace_mon, *this->lock_,
            CORBA::INTERNAL ());
    // @@ CosEventChannelAdmin::EventChannel::SYNCHRONIZATION_ERROR ());

    if (this->is_connected_i () == 0)
      return; // ACE_THROW (CosEventComm::Disconnected ());????

    consumer =
      CosEventComm::PushConsumer::_duplicate (this->consumer_.in ());
  }

  TAO_CEC_ConsumerControl *control =
               this->event_channel_->consumer_control ();
  try
    {
      consumer->push (event);

      // Inform the control that we were able to push something
      control->successful_transmission(this);
    }
  catch (const CORBA::OBJECT_NOT_EXIST&)
    {
      control->consumer_not_exist (this);
    }
  catch (CORBA::SystemException& sysex)
    {
      control->system_exception (this,
                                 sysex);
    }
  catch (const CORBA::Exception&)
    {
      // Shouldn't happen, but does not hurt
    }
}

void TAO_CEC_ProxyPushSupplier::reactive_push_to_consumer

(

const CORBA::Any &

event

)

Definition at line 639 of file CEC_ProxyPushSupplier.cpp.

References CORBA::Exception::_tao_print_exception(), ACE_GUARD, consumer(), TAO_CEC_EventChannel::consumer_control(), event_channel_, TAO_CEC_ConsumerControl::successful_transmission(), and TAO_debug_level.

Referenced by TAO_CEC_Reactive_Dispatching::push(), and TAO_CEC_Reactive_Dispatching::push_nocopy().

{
  CosEventComm::PushConsumer_var consumer;
  {
    ACE_GUARD (ACE_Lock, ace_mon, *this->lock_);
    if (this->is_connected_i () == 0)
      return; // TAO_THROW (CosEventComm::Disconnected ());????

    consumer =
      CosEventComm::PushConsumer::_duplicate (this->consumer_.in ());
  }

  TAO_CEC_ConsumerControl *control =
                  this->event_channel_->consumer_control ();

  try
    {
      consumer->push (event);

      // Inform the control that we were able to push something
      control->successful_transmission(this);
    }
  catch (const CORBA::OBJECT_NOT_EXIST& not_used)
    {
       if (TAO_debug_level >= 4)
        {
          not_used._tao_print_exception (
            "during TAO_CEC_ProxyPushSupplier::reactive_push_to_consumer");
        }
     control->consumer_not_exist (this);
    }
  catch (CORBA::SystemException& sysex)
    {
      if (TAO_debug_level >= 4)
        {
          sysex._tao_print_exception (
            "during TAO_CEC_ProxyPushSupplier::reactive_push_to_consumer");
        }

      control->system_exception (this,
                                 sysex);
    }
  catch (const CORBA::Exception&)
    {
      // Shouldn't happen, but does not hurt
    }
}

void TAO_CEC_ProxyPushSupplier::shutdown

(

void

)

[virtual]

The event channel is shutting down.

Definition at line 135 of file CEC_ProxyPushSupplier.cpp.

References ACE_GUARD_THROW_EX, consumer(), consumer_, deactivate(), and CORBA::is_nil().

{
#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
  if (this->is_typed_ec () )
    {
      // Save the consumer we where connected to, we need to send a
      // disconnect message to it.
      CosTypedEventComm::TypedPushConsumer_var typed_consumer;
      {
        ACE_GUARD_THROW_EX (
            ACE_Lock, ace_mon, *this->lock_,
            CORBA::INTERNAL ());
        // @@ CosEventChannelAdmin::EventChannel::SYNCHRONIZATION_ERROR ());

        typed_consumer = this->typed_consumer_._retn ();
      }

      this->deactivate ();

      if (CORBA::is_nil (typed_consumer.in ()))
        return;

      try
        {
          typed_consumer->disconnect_push_consumer ();
        }
      catch (const CORBA::Exception&)
        {
          // Ignore exceptions, we must isolate other clients from
          // problems on this one.
        }
    } /* this->is_typed_ec */
  else
    {
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */

  // Save the consumer we where connected to, we need to send a
  // disconnect message to it.
  CosEventComm::PushConsumer_var consumer;

  {
    ACE_GUARD_THROW_EX (
        ACE_Lock, ace_mon, *this->lock_,
        CORBA::INTERNAL ());
    // @@ CosEventChannelAdmin::EventChannel::SYNCHRONIZATION_ERROR ());

    consumer = this->consumer_._retn ();
  }

  this->deactivate ();

  if (CORBA::is_nil (consumer.in ()))
    return;

  try
    {
      consumer->disconnect_push_consumer ();
    }
  catch (const CORBA::Exception&)
    {
      // Ignore exceptions, we must isolate other clients from
      // problems on this one.
    }
#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
    } /* ! this->is_typed_ec */
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */
}

---

Member Data Documentation

CosEventComm::PushConsumer_var TAO_CEC_ProxyPushSupplier::consumer_ [private]

The consumer -- use apply_policy() instead of assigning directly to consumer_. This will keep consumer_ and nopolicy_consumer_ in sync.

Definition at line 186 of file CEC_ProxyPushSupplier.h.

Referenced by cleanup_i(), connect_push_consumer(), consumer(), consumer_i(), disconnect_push_supplier(), and shutdown().

PortableServer::POA_var TAO_CEC_ProxyPushSupplier::default_POA_ [private]

Store the default POA.

Definition at line 206 of file CEC_ProxyPushSupplier.h.

TAO_CEC_EventChannel* TAO_CEC_ProxyPushSupplier::event_channel_ [private]

The Event Channel that owns this object.

Definition at line 169 of file CEC_ProxyPushSupplier.h.

Referenced by _decr_refcnt(), apply_policy_obj(), connect_push_consumer(), disconnect_push_supplier(), push(), push_nocopy(), push_to_consumer(), reactive_push_to_consumer(), and ~TAO_CEC_ProxyPushSupplier().

ACE_Lock* TAO_CEC_ProxyPushSupplier::lock_ [private]

The locking strategy.

Definition at line 179 of file CEC_ProxyPushSupplier.h.

CosEventComm::PushConsumer_var TAO_CEC_ProxyPushSupplier::nopolicy_consumer_ [private]

The consumer without any policies applied.

Definition at line 189 of file CEC_ProxyPushSupplier.h.

Referenced by apply_policy().

CORBA::ULong TAO_CEC_ProxyPushSupplier::refcount_ [private]

The reference count.

Definition at line 182 of file CEC_ProxyPushSupplier.h.

Referenced by _decr_refcnt(), and _incr_refcnt().

ACE_Time_Value TAO_CEC_ProxyPushSupplier::timeout_ [private]

Definition at line 171 of file CEC_ProxyPushSupplier.h.

---

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

• CEC_ProxyPushSupplier.h
• CEC_ProxyPushSupplier.cpp
• CEC_ProxyPushSupplier.inl

---