cec_default_factory.cpp

这是广泛使用的通信开源项目,对于大容量,高并发的通讯要求完全能够胜任,他广泛可用于网络游戏医学图像网关的高qos要求.更详细的内容可阅读相应的材料

        }

      else if (ACE_OS::strcasecmp (arg, ACE_LIB_TEXT("-CECSupplierControlPeriod")) == 0)
        {
          arg_shifter.consume_arg ();

          if (arg_shifter.is_parameter_next ())
            {
              const ACE_TCHAR* opt = arg_shifter.get_current ();
              this->supplier_control_period_ = ACE_OS::atoi (opt);
              arg_shifter.consume_arg ();
            }
        }

      else if (ACE_OS::strcasecmp (arg, ACE_LIB_TEXT("-CECConsumerControlTimeout")) == 0)
        {
          arg_shifter.consume_arg ();

          if (arg_shifter.is_parameter_next ())
            {
              const ACE_TCHAR* opt = arg_shifter.get_current ();
			  unsigned long timeout_ = ACE_OS::strtoul(opt, 0, 10);
              this->consumer_control_timeout_.usec(timeout_);
              arg_shifter.consume_arg ();
            }
        }

      else if (ACE_OS::strcasecmp (arg, ACE_LIB_TEXT("-CECSupplierControlTimeout")) == 0)
        {
          arg_shifter.consume_arg ();

          if (arg_shifter.is_parameter_next ())
            {
              const ACE_TCHAR* opt = arg_shifter.get_current ();
			  unsigned long timeout_ = ACE_OS::strtoul(opt, 0, 10);
              this->supplier_control_timeout_.usec(timeout_);
              arg_shifter.consume_arg ();
            }
        }

      else if (ACE_OS::strncmp (arg, ACE_LIB_TEXT("-CEC"), 3) == 0)
        {
          arg_shifter.consume_arg ();
          ACE_ERROR ((LM_ERROR,
                      "CEC_Default_Factory - "
                      "unknown option <%s>\n",
                      arg));
        }
      else
        {
          arg_shifter.consume_arg ();
          ACE_DEBUG ((LM_DEBUG,
                      "CEC_Default_Factory - "
                      "ignoring option <%s>\n",
                      arg));
        }
    }
  return 0;
}

int
TAO_CEC_Default_Factory::fini (void)
{
  return 0;
}

// ****************************************************************

TAO_CEC_Dispatching*
TAO_CEC_Default_Factory::create_dispatching (TAO_CEC_EventChannel *)
{
  if (this->dispatching_ == 0)
    return new TAO_CEC_Reactive_Dispatching ();
  else if (this->dispatching_ == 1)
    return new TAO_CEC_MT_Dispatching (this->dispatching_threads_,
                                      this->dispatching_threads_flags_,
                                      this->dispatching_threads_priority_,
                                      this->dispatching_threads_force_active_);
  return 0;
}

#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
TAO_CEC_Dispatching*
TAO_CEC_Default_Factory::create_dispatching (TAO_CEC_TypedEventChannel *)
{
  if (this->dispatching_ == 0)
    return new TAO_CEC_Reactive_Dispatching ();
  else if (this->dispatching_ == 1)
    return new TAO_CEC_MT_Dispatching (this->dispatching_threads_,
                                      this->dispatching_threads_flags_,
                                      this->dispatching_threads_priority_,
                                      this->dispatching_threads_force_active_);
  return 0;
}
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */

void
TAO_CEC_Default_Factory::destroy_dispatching (TAO_CEC_Dispatching *x)
{
  delete x;
}

TAO_CEC_Pulling_Strategy*
TAO_CEC_Default_Factory::create_pulling_strategy (TAO_CEC_EventChannel *ec)
{
  if (this->pulling_strategy_ == 0)
    {
      int argc = 0;
      char **argv = 0;
      CORBA::ORB_var orb =
        CORBA::ORB_init (argc, argv, this->orbid_);

      ACE_Time_Value rate (0, this->reactive_pulling_period_);
      return new TAO_CEC_Reactive_Pulling_Strategy (rate, ec,
                                                    orb.in ());
    }
  return 0;
}

void
TAO_CEC_Default_Factory::destroy_pulling_strategy (TAO_CEC_Pulling_Strategy *x)
{
  delete x;
}

TAO_CEC_ConsumerAdmin*
TAO_CEC_Default_Factory::create_consumer_admin (TAO_CEC_EventChannel *ec)
{
  return new TAO_CEC_ConsumerAdmin (ec);
}

#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
TAO_CEC_TypedConsumerAdmin*
TAO_CEC_Default_Factory::create_consumer_admin (TAO_CEC_TypedEventChannel *ec)
{
  return new TAO_CEC_TypedConsumerAdmin (ec);
}
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */

void
TAO_CEC_Default_Factory::destroy_consumer_admin (TAO_CEC_ConsumerAdmin *x)
{
  delete x;
}

#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
void
TAO_CEC_Default_Factory::destroy_consumer_admin (TAO_CEC_TypedConsumerAdmin *x)
{
  delete x;
}
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */

TAO_CEC_SupplierAdmin*
TAO_CEC_Default_Factory::create_supplier_admin (TAO_CEC_EventChannel *ec)
{
  return new TAO_CEC_SupplierAdmin (ec);
}

#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
TAO_CEC_TypedSupplierAdmin*
TAO_CEC_Default_Factory::create_supplier_admin (TAO_CEC_TypedEventChannel *ec)
{
  return new TAO_CEC_TypedSupplierAdmin (ec);
}
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */

void
TAO_CEC_Default_Factory::destroy_supplier_admin (TAO_CEC_SupplierAdmin *x)
{
  delete x;
}

#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
void
TAO_CEC_Default_Factory::destroy_supplier_admin (TAO_CEC_TypedSupplierAdmin *x)
{
  delete x;
}
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */

TAO_CEC_ProxyPushSupplier*
TAO_CEC_Default_Factory::create_proxy_push_supplier (TAO_CEC_EventChannel *ec)
{
  return new TAO_CEC_ProxyPushSupplier (ec);
}

#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
TAO_CEC_ProxyPushSupplier*
TAO_CEC_Default_Factory::create_proxy_push_supplier (TAO_CEC_TypedEventChannel *ec)
{
  return new TAO_CEC_ProxyPushSupplier (ec);
}
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */

void
TAO_CEC_Default_Factory::destroy_proxy_push_supplier (TAO_CEC_ProxyPushSupplier *x)
{
  delete x;
}

TAO_CEC_ProxyPullSupplier*
TAO_CEC_Default_Factory::create_proxy_pull_supplier (TAO_CEC_EventChannel *ec)
{
  return new TAO_CEC_ProxyPullSupplier (ec);
}

void
TAO_CEC_Default_Factory::destroy_proxy_pull_supplier (TAO_CEC_ProxyPullSupplier *x)
{
  delete x;
}

TAO_CEC_ProxyPushConsumer*
TAO_CEC_Default_Factory::create_proxy_push_consumer (TAO_CEC_EventChannel *ec)
{
  return new TAO_CEC_ProxyPushConsumer (ec);
}

#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
TAO_CEC_TypedProxyPushConsumer*
TAO_CEC_Default_Factory::create_proxy_push_consumer (TAO_CEC_TypedEventChannel *ec)
{
  return new TAO_CEC_TypedProxyPushConsumer (ec);
}
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */

void
TAO_CEC_Default_Factory::destroy_proxy_push_consumer (TAO_CEC_ProxyPushConsumer *x)
{
  delete x;
}

#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
void
TAO_CEC_Default_Factory::destroy_proxy_push_consumer (TAO_CEC_TypedProxyPushConsumer *x)
{
  delete x;
}
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */

TAO_CEC_ProxyPullConsumer*
TAO_CEC_Default_Factory::create_proxy_pull_consumer (TAO_CEC_EventChannel *ec)
{
  return new TAO_CEC_ProxyPullConsumer (ec);
}

void
TAO_CEC_Default_Factory::destroy_proxy_pull_consumer (TAO_CEC_ProxyPullConsumer *x)
{
  delete x;
}

// These typedefs workaround a SunCC 4.2 bug
typedef
    TAO_ESF_Proxy_List<TAO_CEC_ProxyPushConsumer>::Iterator
    TAO_CEC_PushConsumer_List_Iterator;
typedef
    TAO_ESF_Proxy_RB_Tree<TAO_CEC_ProxyPushConsumer>::Iterator
    TAO_CEC_PushConsumer_RB_Tree_Iterator;
#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
typedef
    TAO_ESF_Proxy_List<TAO_CEC_TypedProxyPushConsumer>::Iterator
    TAO_CEC_TypedPushConsumer_List_Iterator;
typedef
    TAO_ESF_Proxy_RB_Tree<TAO_CEC_TypedProxyPushConsumer>::Iterator
    TAO_CEC_TypedPushConsumer_RB_Tree_Iterator;
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */
typedef
    TAO_ESF_Proxy_List<TAO_CEC_ProxyPullConsumer>::Iterator
    TAO_CEC_PullConsumer_List_Iterator;
typedef
    TAO_ESF_Proxy_RB_Tree<TAO_CEC_ProxyPullConsumer>::Iterator
    TAO_CEC_PullConsumer_RB_Tree_Iterator;
typedef
    TAO_ESF_Proxy_List<TAO_CEC_ProxyPushSupplier>::Iterator
    TAO_CEC_PushSupplier_List_Iterator;
typedef
    TAO_ESF_Proxy_RB_Tree<TAO_CEC_ProxyPushSupplier>::Iterator
    TAO_CEC_PushSupplier_RB_Tree_Iterator;
typedef
    TAO_ESF_Proxy_List<TAO_CEC_ProxyPullSupplier>::Iterator
    TAO_CEC_PullSupplier_List_Iterator;
typedef
    TAO_ESF_Proxy_RB_Tree<TAO_CEC_ProxyPullSupplier>::Iterator
    TAO_CEC_PullSupplier_RB_Tree_Iterator;

TAO_CEC_ProxyPushConsumer_Collection*
TAO_CEC_Default_Factory::create_proxy_push_consumer_collection (TAO_CEC_EventChannel *)
{
  if (this->consumer_collection_ == 0x000)
    return new TAO_ESF_Immediate_Changes<TAO_CEC_ProxyPushConsumer,
      TAO_ESF_Proxy_List<TAO_CEC_ProxyPushConsumer>,
      TAO_CEC_PushConsumer_List_Iterator,
      TAO_SYNCH_MUTEX> ();
  else if (this->consumer_collection_ == 0x001)
    return new TAO_ESF_Copy_On_Read<TAO_CEC_ProxyPushConsumer,
      TAO_ESF_Proxy_List<TAO_CEC_ProxyPushConsumer>,
      TAO_CEC_PushConsumer_List_Iterator,
      TAO_SYNCH_MUTEX> ();
  else if (this->consumer_collection_ == 0x002)
    return new TAO_ESF_Copy_On_Write<TAO_CEC_ProxyPushConsumer,
      TAO_ESF_Proxy_List<TAO_CEC_ProxyPushConsumer>,
      TAO_CEC_PushConsumer_List_Iterator,
      ACE_SYNCH> ();
  else if (this->consumer_collection_ == 0x003)
    return new TAO_ESF_Delayed_Changes<TAO_CEC_ProxyPushConsumer,
      TAO_ESF_Proxy_List<TAO_CEC_ProxyPushConsumer>,
      TAO_CEC_PushConsumer_List_Iterator,
      ACE_SYNCH> ();
  else if (this->consumer_collection_ == 0x010)
    return new TAO_ESF_Immediate_Changes<TAO_CEC_ProxyPushConsumer,
      TAO_ESF_Proxy_RB_Tree<TAO_CEC_ProxyPushConsumer>,
      TAO_CEC_PushConsumer_RB_Tree_Iterator,
      TAO_SYNCH_MUTEX> ();
  else if (this->consumer_collection_ == 0x011)
    return new TAO_ESF_Copy_On_Read<TAO_CEC_ProxyPushConsumer,
      TAO_ESF_Proxy_RB_Tree<TAO_CEC_ProxyPushConsumer>,
      TAO_CEC_PushConsumer_RB_Tree_Iterator,
      TAO_SYNCH_MUTEX> ();
  else if (this->consumer_collection_ == 0x012)
    return new TAO_ESF_Copy_On_Write<TAO_CEC_ProxyPushConsumer,