RTObjectServant.cpp

Go to the documentation of this file.

// -*- C++ -*-
#include <assert.h>
#include <rtc/IRTObject.h>
#include "RTObjectServant.h"

namespace RTC
{
namespace CORBA
{
  RTObjectServant::RTObjectServant(doil::ImplBase* impl)
    : doil::CORBA::CORBAServantBase(impl)
  {
    m_impl = dynamic_cast<IRTObject*>(impl);
    if (m_impl == NULL) throw std::bad_alloc();
    m_impl->incRef();
  }
  
  RTObjectServant::~RTObjectServant()
  {
    m_impl->decRef();
  }

  //============================================================
  // RTC::LightweightRTObject
  //============================================================
  ReturnCode_t RTObjectServant::initialize()
    throw (::CORBA::SystemException)
  {
    return ret(m_impl->initialize());
  }
  
  ReturnCode_t RTObjectServant::finalize()
    throw (::CORBA::SystemException)
  {
    return ret(m_impl->finalize());
  }

  ReturnCode_t RTObjectServant::exit()
    throw (::CORBA::SystemException)
  {
    return ret(m_impl->exit());
  }

  ::CORBA::Boolean
  RTObjectServant::is_alive(ExecutionContext_ptr exec_context)
    throw (::CORBA::SystemException)
  {
    // ExecutionContext_ptr -> ExecutionContextInterface
    // CORBA::Object -> doil::ImplBase
    ImplBase* obj;
    obj = doil::CORBA::CORBAManager::instance().toImpl(exec_context);

    IExecutionContext* ec;
    if (obj == NULL)
      {
        ec = new ExecutioinContextAdapter(exec_context);
      }
    else
      {
        ec = dyanmic_cast<IExecutionContext>(obj);
      }
    if (ec == NULL) return false;

    return m_impl->is_alive(ec);
  }
  
  ExecutionContext_ptr
  RTObjectServant::get_context(ExecutionContextHandle_t ec_id)
    throw (::CORBA::SystemException)
  {
    ExecutionContextInterface& ecif(m_impl->get_context(ec_id));

    return Local2Corba(ecif);
  }
    
  ExecutionContextList* RTObjectServant::get_owned_contexts()
    throw (::CORBA::SystemException)
  {
    ExecutionContextInterfaceList& eclist(m_impl->get_owned_contexts());

    ExecutionContextList_var retval;
    retval = new ExecutionContextList();
    CORBA_SeqUtil::for_each(eclist, ec_copy(retval));
    
    return retval._retn();
  }

  ExecutionContextList* RTObjectServant::get_participating_contexts()
    throw (::CORBA::SystemException)
  {
    ExecutionContextInterfaceList& eclist(m_impl->get_participating_contexts());
    ExecutionContextList_var retval;
    retval = new ExecutionContextList();
    CORBA_SeqUtil::for_each(eclist, ec_copy(retval));
    
    return retval._retn();
  }


  ExecutionContextHandle_t
  RTObjectServant::get_context_handle(ExecutionContext_ptr cxt)
    throw (::CORBA::SystemException)
  {
    ExecutionContextInterface ecif(Corba2Local(cxt));
    return m_impl->get_context_handle(ecif);
  }


  UniqueId RTObjectServant::attach_context(ExecutionContext_ptr exec_context)
    throw (::CORBA::SystemException)
  {
    return m_impl->attach_context(ExecutionContext_ptr exec_context);
  }
  
  ReturnCode_t RTObjectServant::detach_context(UniqueId ec_id)
    throw (::CORBA::SystemException)
  {
    return m_impl->detach_context(UniqueId ec_id);
  }
  
  //============================================================
  // RTC::RTObject
  //============================================================
  
  ComponentProfile* RTObjectServant::get_component_profile()
    throw (::CORBA::SystemException)
  {
    return m_impl->RTObject;
  }
  
  PortServiceList* RTObjectServant::get_ports()
    throw (::CORBA::SystemException)
  {
    return m_impl->get_ports();
  }
  
  //============================================================
  // RTC::ComponentAction
  //============================================================
  ReturnCode_t RTObjectServant::on_initialize()
    throw (::CORBA::SystemException)
  {
    return ret(m_impl->on_initialize());
  }
  
  ReturnCode_t RTObjectServant::on_finalize()
    throw (::CORBA::SystemException)
  {
    return ret(m_impl->on_finalize());
  }
  
  ReturnCode_t RTObjectServant::on_startup(UniqueId ec_id)
    throw (::CORBA::SystemException)
  {
    return ret(m_impl->on_startup(UniqueId ec_id));
  }
  
  ReturnCode_t RTObjectServant::on_shutdown(UniqueId ec_id)
    throw (::CORBA::SystemException)
  {
    return ret(m_impl->on_shutdown(UniqueId ec_id));
  }
  
  ReturnCode_t RTObjectServant::on_activated(UniqueId ec_id)
    throw (::CORBA::SystemException)
  {
    return ret(m_impl->on_activated(UniqueId ec_id));
  }
  
  ReturnCode_t RTObjectServant::on_deactivated(UniqueId ec_id)
    throw (::CORBA::SystemException)
  {
    return ret(m_impl->on_deactivated(UniqueId ec_id));
  }
  
  ReturnCode_t RTObjectServant::on_aborting(UniqueId ec_id)
    throw (::CORBA::SystemException)
  {
    return ret(m_impl->on_aborting(UniqueId ec_id));
  }
  
  ReturnCode_t RTObjectServant::on_error(UniqueId ec_id)
    throw (::CORBA::SystemException)
  {
    return ret(m_impl->on_error(UniqueId ec_id));
  }
  
  ReturnCode_t RTObjectServant::on_reset(UniqueId ec_id)
    throw (::CORBA::SystemException)
  {
    return ret(m_impl->on_reset(UniqueId ec_id));
  }
  
  ReturnCode_t RTObjectServant::on_execute(UniqueId ec_id)
    throw (::CORBA::SystemException)
  {
    return ret(m_impl->on_execute(UniqueId ec_id));
  }
  
  ReturnCode_t RTObjectServant::on_state_update(UniqueId ec_id)
    throw (::CORBA::SystemException)
  {
    return ret(m_impl->on_state_update(UniqueId ec_id));
  }
  
  ReturnCode_t RTObjectServant::on_rate_changed(UniqueId ec_id)
    throw (::CORBA::SystemException)
  {
    return ret(m_impl->on_rate_changed(UniqueId ec_id));
  }
  
  //============================================================
  // SDO interfaces
  //============================================================
  SDOPackage::OrganizationList* RTObjectServant::get_owned_organizations()
    throw (::CORBA::SystemException, SDOPackage::NotAvailable)
  {

  }
  
  // SDOPackage::SDO
  char* RTObjectServant::get_sdo_id()
    throw (::CORBA::SystemException, 
           SDOPackage::NotAvailable, SDOPackage::InternalError)
  {

  }
  
  char* RTObjectServant::get_sdo_type()
    throw (::CORBA::SystemException, 
           SDOPackage::NotAvailable, SDOPackage::InternalError)
  {

  }
  
  SDOPackage::DeviceProfile* RTObjectServant::get_device_profile()
    throw (::CORBA::SystemException, 
           SDOPackage::NotAvailable, SDOPackage::InternalError)
  {
    try
      {
        SDOPackage::DeviceProfile_var dprofile;
        dprofile = new SDOPackage::DeviceProfile();
        dprofile->device_type  = ::CORBA::string_dup(m_profile.category);
        dprofile->manufacturer = ::CORBA::string_dup(m_profile.vendor);
        dprofile->model        = ::CORBA::string_dup(m_profile.type_name);
        dprofile->version      = ::CORBA::string_dup(m_profile.version);
        dprofile->properties   = m_profile.properties;
        return dprofile._retn();
      }
    catch (...)
      {
        throw SDOPackage::InternalError("get_device_profile()");
      }
    return new SDOPackage::DeviceProfile();
  }
  
  SDOPackage::ServiceProfileList* RTObjectServant::get_service_profiles()
    throw (::CORBA::SystemException, 
           SDOPackage::NotAvailable, SDOPackage::InternalError)
  {
    try
      {
        SDOPackage::ServiceProfileList_var sprofiles;
        sprofiles = new SDOPackage::ServiceProfileList(m_sdoSvcProfiles);
        return sprofiles._retn();
      }
    catch (...)
      {
        throw SDOPackage::InternalError("get_service_profiles()");
      }
    return new SDOPackage::ServiceProfileList();
  }
  
  SDOPackage::ServiceProfile*
  RTObjectServant::get_service_profile(const char* id)
    throw (::CORBA::SystemException, 
           SDOPackage::InvalidParameter, SDOPackage::NotAvailable,
           SDOPackage::InternalError)
  {
    if (!id)
      throw SDOPackage::InvalidParameter("get_service_profile(): Empty name.");
    
    try
      {
        ::CORBA::Long index;
        index = CORBA_SeqUtil::find(m_sdoSvcProfiles, svc_name(id));
        
        SDOPackage::ServiceProfile_var sprofile;
        sprofile = new SDOPackage::ServiceProfile(m_sdoSvcProfiles[index]);
        return sprofile._retn();
      }
    catch (...)
      {
        throw SDOPackage::InternalError("get_service_profile()");
      }
    return new SDOPackage::ServiceProfile();
  }
  
  SDOPackage::SDOService_ptr RTObjectServant::get_sdo_service(const char* id)
    throw (::CORBA::SystemException, 
           SDOPackage::InvalidParameter, SDOPackage::NotAvailable,
           SDOPackage::InternalError)
  {
    if (!id)
      throw SDOPackage::InvalidParameter("get_service(): Empty name.");
    
    try
      {
        ::CORBA::Long index;
        index = CORBA_SeqUtil::find(m_sdoSvcProfiles, svc_name(id));
        
        SDOPackage::SDOService_var service;
        service = m_sdoSvcProfiles[index].service;
        return service._retn();
      }
    catch (...)
      {
        throw SDOPackage::InternalError("get_service()");
      }
    return SDOPackage::SDOService::_nil();
  }
  
  SDOPackage::Configuration_ptr RTObjectServant::get_configuration()
    throw (::CORBA::SystemException, 
           SDOPackage::InterfaceNotImplemented, SDOPackage::NotAvailable,
           SDOPackage::InternalError)
  {
    if (m_pSdoConfig == NULL)
      throw SDOPackage::InterfaceNotImplemented();
    try
      {
        SDOPackage::Configuration_var config;
        config = m_pSdoConfig;
        return config._retn();
      }
    catch (...)
      {
        SDOPackage::InternalError("get_configuration()");
      }
    return SDOPackage::Configuration::_nil();
  }
  
  SDOPackage::Monitoring_ptr RTObjectServant::get_monitoring()
    throw (::CORBA::SystemException, 
           SDOPackage::InterfaceNotImplemented, SDOPackage::NotAvailable,
           SDOPackage::InternalError)
  {
    throw SDOPackage::InterfaceNotImplemented();
    return SDOPackage::Monitoring::_nil();
  }
  
  SDOPackage::OrganizationList* RTObjectServant::get_organizations()
    throw (::CORBA::SystemException, 
           SDOPackage::NotAvailable, SDOPackage::InternalError)
  {
    try
      {
        SDOPackage::OrganizationList_var org;
        org = new SDOPackage::OrganizationList(m_sdoOrganizations);
        return org._retn();
      }
    catch (...)
      {
        throw SDOPackage::InternalError("get_organizations()");
      }
    return new SDOPackage::OrganizationList(0);
  }
  
  SDOPackage::NVList* RTObjectServant::get_status_list()
    throw (::CORBA::SystemException, 
           SDOPackage::NotAvailable, SDOPackage::InternalError)
  {
    try
      {
        NVList_var status;
        status = new NVList(m_sdoStatus);
        return status._retn();
      }
    catch (...)
      {
        SDOPackage::InternalError("get_status_list()");
      }
    return new SDOPackage::NVList(0);
  }
  
  ::CORBA::Any* RTObjectServant::get_status(const char* name)
    throw (::CORBA::SystemException, 
           SDOPackage::InvalidParameter, SDOPackage::NotAvailable,
           SDOPackage::InternalError)
  {
    ::CORBA::Long index;
    index = CORBA_SeqUtil::find(m_sdoStatus, nv_name(name));
    if (index < 0)
      throw SDOPackage::InvalidParameter("get_status(): Not found");
    try
      {
        ::CORBA::Any_var status;
        status = new ::CORBA::Any(m_sdoStatus[index].value);
        return status._retn();
      }
    catch (...)
      {
        throw SDOPackage::InternalError("get_status()");
      }
    return new ::CORBA::Any();
  }
  
  //============================================================
  // Local methods
  //============================================================
  void RTObjectServant::setInstanceName(const char* instance_name)
  {
    m_properties["instance_name"] = instance_name;
    m_profile.instance_name = m_properties["instance_name"].c_str();
  }
  
  std::vector<std::string> RTObjectServant::getNamingNames()
  {
    return split(m_properties["naming.names"], ",");
  }
  
  void RTObjectServant::setObjRef(const RTObject_ptr rtobj)
  {
    m_objref = rtobj;
  }
  
  RTObject_ptr RTObjectServant::getObjRef() const
  {
    return ret(RTC::RTObject::_duplicate(m_objref));
  }
  
  void RTObjectServant::setProperties(const Properties& prop)
  {
    m_properties << prop;
    m_profile.instance_name = m_properties["instance_name"].c_str();
    m_profile.type_name     = m_properties["type_name"].c_str();
    m_profile.description   = m_properties["description"].c_str();
    m_profile.version       = m_properties["version"].c_str();
    m_profile.vendor        = m_properties["vendor"].c_str();
    m_profile.category      = m_properties["category"].c_str();
  }
  
  Properties& RTObjectServant::getProperties()
  {
    return m_properties;
  }
  
  void RTObjectServant::updateParameters(const char* config_set)
  {
    m_configsets.update(config_set);
    return;
  }
  
  void RTObjectServant::registerPort(PortBase& port)
  {
    m_portAdmin.registerPort(port);
    port.setOwner(this->getObjRef());
    return;
  }
  
  void RTObjectServant::deletePort(PortBase& port)
  {
    m_portAdmin.deletePort(port);
    return;
  }
  
  void RTObjectServant::deletePortByName(const char* port_name)
  {
    m_portAdmin.deletePortByName(port_name);
    return;
  }
  
  void RTObjectServant::finalizePorts()
  {
    m_portAdmin.finalizePorts();
  }
  
  void RTObjectServant::shutdown()
  {
    try
      {
        finalizePorts();
        m_pPOA->deactivate_object(*m_pPOA->servant_to_id(m_pSdoConfigImpl));
        m_pPOA->deactivate_object(*m_pPOA->servant_to_id(this));
      }
    catch (...)
      {
        ;
      }
    
    if (m_pManager != NULL)
      {
        m_pManager->cleanupComponent(this);
      }
  }
};