C++ Object_var::_retn方法代码示例

CORBA::Object_ptr AutomaticGainControl_i::getPort( const char* portName ) throw (CORBA::SystemException, CF::PortSupplier::UnknownPort)
{
    DEBUG(3, AutomaticGainControl, "getPort() invoked with : " << portName)
    CORBA::Object_var p;

    p = dataOut_0->getPort(portName);
    if (!CORBA::is_nil(p))
        return p._retn();

    p = dataIn_0->getPort(portName);
    if (!CORBA::is_nil(p))
        return p._retn();
    /*exception*/
    throw CF::PortSupplier::UnknownPort();
}

CORBA::Object_ptr
TAO_CEC_ProxyPushSupplier::apply_policy_obj (CORBA::Object_ptr pre)
{
#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 defined (TAO_HAS_TYPED_EVENT_CHANNEL)
      if (this->typed_event_channel_)
        {
          policy_list[0] = this->typed_event_channel_->
            create_roundtrip_timeout_policy (this->timeout_);
        }
      else
        {
#endif
          policy_list[0] = this->event_channel_->
            create_roundtrip_timeout_policy (this->timeout_);
#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
        }
#endif
      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
Basic::init_CosEC (void)
{
  CosEC_ServantBase *ec = 0;

  ACE_NEW_THROW_EX (ec,
                    CosEC_ServantBase (),
                    CORBA::NO_MEMORY ());

  PortableServer::ServantBase_var ec_var (ec);

  ec->init (this->root_poa_.in(),
            this->root_poa_.in(),
            0,0,0);

  int retval = ec->activate ();

  if (retval == -1)
    throw CORBA::UNKNOWN ();
  // @@ look for more descriptive exception to throw here

  CORBA::Object_var obj =
    this->root_poa_->servant_to_reference (ec);

  this->cos_ec_ =
    CosEventChannelAdmin::EventChannel::_narrow (obj._retn ());
}

const char *
Plan_Launcher_Base_Impl< Manager, AppManager, Application>
::launch_plan (const ::Deployment::DeploymentPlan &plan,
               CORBA::Object_out am_out,
               CORBA::Object_out app_out)
{
  DANCE_TRACE ("Plan_Launcher_Base_Impl::launch_plan");

  try
    {
      CORBA::Object_var app_mgr = this->prepare_plan (plan);

      ::Deployment::Connections_var conns;

      CORBA::Object_var app = this->start_launch (app_mgr.in (),
                                                  0,
                                                  conns.out ());

      this->finish_launch (app.in (),
                           conns,
                           false);

      this->start (app.in ());

      DANCE_DEBUG (DANCE_LOG_MAJOR_EVENT,
                   (LM_DEBUG, DLINFO
                    ACE_TEXT ("Plan_Launcher_Base_Impl::launch_plan - ")
                    ACE_TEXT ("Application Deployed successfully\n")));

      am_out = app_mgr._retn ();
      app_out = app._retn ();
    }
  catch (const CORBA::Exception& ex)
    {
      char buf[1024];
      ACE_OS::sprintf (buf, "Plan_Launcher_Base_Impl::launch_plan - CORBA EXCEPTION: <%s>\n",
                       ex._info().fast_rep());
      DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR,
                   (LM_ERROR, DLINFO ACE_TEXT("%C"), buf));
      throw Deployment_Failure (buf);
    }
  catch (const Deployment_Failure &)
    {
      throw;
    }
  catch (...)
    {
      char buf[1024];
      ACE_OS::sprintf (buf, "Plan_Launcher_Base_Impl::launch_plan - EXCEPTION: non-CORBA exception\n");
      DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR,
                   (LM_ERROR, DLINFO ACE_TEXT("%C"), buf));
      throw Deployment_Failure (buf);
    }

  return plan.UUID.in();
}

CORBA::Object_ptr amplifier_i::getPort( const char* portName ) throw (CORBA::SystemException, CF::PortSupplier::UnknownPort)
{
    std::cout << "amplifier_i getPort called with : " << portName << std::endl;

    CORBA::Object_var p;

    p = dataOut_0->getPort(portName);

    if (!CORBA::is_nil(p))
        return p._retn();

    p = dataIn_0->getPort(portName);

    if (!CORBA::is_nil(p))
        return p._retn();

    /*exception*/
    throw CF::PortSupplier::UnknownPort();
}

CORBA::Object_ptr Channel_i::getPort(const char*portName)
throw ( CORBA::SystemException, CF::PortSupplier::UnknownPort)
{
    DEBUG(3, Channel, "getPort() invoked with " << portName)

    CORBA::Object_var p;

    p = dataIn->getPort(portName);

    if (!CORBA::is_nil(p))
        return p._retn();

    p = dataOut->getPort(portName);

    if (!CORBA::is_nil(p))
        return p._retn();

    /*exception*/
    throw CF::PortSupplier::UnknownPort();
}

CORBA::Object_ptr ConnectionManager::resolveComponent(const std::string& identifier)
{
    CORBA::Object_var target = _componentLookup->lookupComponentByInstantiationId(identifier);
    if (CORBA::is_nil(target)) {
        target = _componentLookup->lookupDeviceManagerByInstantiationId(identifier);
    }
    if (CORBA::is_nil(target)) {
        LOG_DEBUG(ConnectionManager, "Could not locate component with instantiation id " << identifier);
    }
    return target._retn();
}

CORBA::Object_ptr
TAO_Notify_RT_StructuredProxyPushSupplier::activate (PortableServer::Servant servant)
{
  CORBA::Object_var object = TAO_Notify_Proxy::activate (servant);

  // Obtain our ref.
  CORBA::Object_var obj = this->ref ();

  this->event_forwarder_ = Event_Forwarder::StructuredProxyPushSupplier::_narrow (obj.in ());

  return object._retn ();
}

CORBA::Object_ptr
TAO_Notify_Tests_LookupManager::resolve_object (const char* obj_name)
{
  CosNaming::Name name (1);
  name.length (1);
  name[0].id = CORBA::string_dup (obj_name);

  CORBA::Object_var obj =
    this->naming_->resolve (name);

  return obj._retn ();
}

CORBA::Object_ptr
HomeServantBase::create_primary_object_reference (const char* rep_id)
{
	Qedo::Key* key = new Qedo::Key();
	CORBA::OctetSeq_var key_seq = key->key_value();

	CORBA::Object_var obj = create_object_reference (&key_seq.in(), rep_id);

	key->_remove_ref();

	return obj._retn();
}

CORBA::Object_ptr TAO::Object_Group_Creator::create_infrastructure_managed_group (
    const char * type_id)
{
  CORBA::Object_var group = CORBA::Object::_nil ();

  if (this->have_replication_manager_)
  {
    // set typeid properties
    PortableGroup::Properties properties (1);
    properties.length (3);

    properties[0].nam.length (1);
    properties[0].nam[0].id = PortableGroup::PG_MEMBERSHIP_STYLE;
    properties[0].val <<= PortableGroup::MEMB_INF_CTRL;

    PortableGroup::InitialNumberMembersValue inm(2);
    properties[1].nam.length (1);
    properties[1].nam[0].id = PortableGroup::PG_INITIAL_NUMBER_MEMBERS;
    properties[1].val <<= inm;

    PortableGroup::MinimumNumberMembersValue mnm(1);
    properties[2].nam.length (1);
    properties[2].nam[0].id = PortableGroup::PG_MINIMUM_NUMBER_MEMBERS;
    properties[2].val <<= mnm;

    this->replication_manager_->set_type_properties (
      type_id,
      properties);

    ::PortableGroup::GenericFactory::FactoryCreationId_var creation_id;
    PortableGroup::Criteria criteria (1);
    criteria.length (1);
    criteria[0].nam.length (1);
    criteria[0].nam[0].id = PortableGroup::PG_MEMBERSHIP_STYLE;
    criteria[0].val <<= PortableGroup::MEMB_APP_CTRL;

    group = this->replication_manager_->create_object (
      type_id,
      criteria,
      creation_id
      );
  }
  else
  {
    ACE_ERROR ((LM_ERROR,
      ACE_TEXT("%T %n (%P|%t): Object_Group_Creator: infrastructure managed group requires Replication Manager\n")
      ));
  }
  return group._retn ();
}

CORBA::Object_ptr WebCamCapture_i::getPort( const char* portName ) throw (CORBA::SystemException, CF::PortSupplier::UnknownPort)
{
    DEBUG(3, WebCamCapture, "getPort invoked with port name: " << portName)

    CORBA::Object_var p;

    p = dataOut_0->getPort(portName);

    if (!CORBA::is_nil(p))
        return p._retn();

    /*exception*/
    throw CF::PortSupplier::UnknownPort();
}

CORBA::Object_ptr writeBytestoFile_i::getPort( const char* portName ) throw (
    CORBA::SystemException, CF::PortSupplier::UnknownPort)
{
    DEBUG(3, writeBytestoFile, "getPort() invoked with " << portName)

    CORBA::Object_var p;

    p = dataIn_0->getPort(portName);

    if (!CORBA::is_nil(p))
        return p._retn();

    /*exception*/
    throw CF::PortSupplier::UnknownPort();
}

CORBA::Object* ossie::corba::activateGCObject(PortableServer::POA_ptr poa,
                                              PortableServer::Servant servant,
                                              boost::posix_time::time_duration ttl,
                                              const std::string& destroy)
{
    PortableServer::ServantManager_var manager = poa->get_servant_manager();
    PortableServer::Servant mgr_servant = ossie::corba::RootPOA()->reference_to_servant(manager);
    GCServantLocator* gc_manager = dynamic_cast<GCServantLocator*>(mgr_servant);
    if (!gc_manager) {
        throw PortableServer::POA::WrongPolicy();
    }
    CORBA::Object_var obj = poa->create_reference(servant->_mostDerivedRepoId());
    PortableServer::ObjectId_var oid = poa->reference_to_id(obj);
    gc_manager->register_servant(oid, servant, ttl, destroy);
    return obj._retn();
}

CORBA::Object_ptr
AppHelper::activate_servant(PortableServer::POA_ptr poa,
                            PortableServer::Servant servant)
{
  // Activate the servant using the Child POA.
  PortableServer::ObjectId_var oid
    = poa->activate_object(servant);

  CORBA::Object_var obj
    = poa->servant_to_reference(servant);

  if (CORBA::is_nil(obj.in()))
    {
      ACE_ERROR((LM_ERROR,
                 "(%P|%t) Failed to convert servant_to_ref.\n"));
      throw TestAppException();
    }

  return obj._retn();
}