bool
IceProxy::kelp::cmd2kcn::setNodeConfig(const ::std::string& uuid, const ::std::string& key, const ::std::string& value, const ::Ice::Context* __ctx)
{
::IceInternal::InvocationObserver __observer(this, __kelp__cmd2kcn__setNodeConfig_name, __ctx);
int __cnt = 0;
while(true)
{
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
try
{
__checkTwowayOnly(__kelp__cmd2kcn__setNodeConfig_name);
__delBase = __getDelegate(false);
::IceDelegate::kelp::cmd2kcn* __del = dynamic_cast< ::IceDelegate::kelp::cmd2kcn*>(__delBase.get());
return __del->setNodeConfig(uuid, key, value, __ctx, __observer);
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__delBase, __ex, __observer);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__delBase, __ex, true, __cnt, __observer);
}
}
}
::std::string
IceProxy::pera::Demo601Server::PeraDemo601ServerService::InvokeMethod(const ::std::string& methodName, const ::std::string& strJsonIn, const ::Ice::Context* __ctx)
{
::IceInternal::InvocationObserver __observer(this, __pera__Demo601Server__PeraDemo601ServerService__InvokeMethod_name, __ctx);
int __cnt = 0;
while(true)
{
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
try
{
__checkTwowayOnly(__pera__Demo601Server__PeraDemo601ServerService__InvokeMethod_name);
__delBase = __getDelegate(false);
::IceDelegate::pera::Demo601Server::PeraDemo601ServerService* __del = dynamic_cast< ::IceDelegate::pera::Demo601Server::PeraDemo601ServerService*>(__delBase.get());
return __del->InvokeMethod(methodName, strJsonIn, __ctx, __observer);
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__delBase, __ex, __observer);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__delBase, __ex, true, __cnt, __observer);
}
}
}
void
IceProxy::RoboCompJoyStick::JoyStick::readJoyStickBufferedData(::RoboCompJoyStick::JoyStickBufferedData& gbd, const ::Ice::Context* __ctx)
{
::IceInternal::InvocationObserver __observer(this, __RoboCompJoyStick__JoyStick__readJoyStickBufferedData_name, __ctx);
int __cnt = 0;
while(true)
{
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
try
{
__checkTwowayOnly(__RoboCompJoyStick__JoyStick__readJoyStickBufferedData_name);
__delBase = __getDelegate(false);
::IceDelegate::RoboCompJoyStick::JoyStick* __del = dynamic_cast< ::IceDelegate::RoboCompJoyStick::JoyStick*>(__delBase.get());
__del->readJoyStickBufferedData(gbd, __ctx, __observer);
return;
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapperRelaxed(__delBase, __ex, true, __cnt, __observer);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__delBase, __ex, true, __cnt, __observer);
}
}
}
::com::renren::sixin::account::VersionResultPtr
IceProxy::com::renren::sixin::account::MiscService::getAppVersion(::Ice::Long userId, const ::Ice::Context* __ctx)
{
int __cnt = 0;
while(true)
{
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
try
{
#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
IceUtil::DummyBCC dummy;
#endif
__checkTwowayOnly(__com__renren__sixin__account__MiscService__getAppVersion_name);
__delBase = __getDelegate(false);
::IceDelegate::com::renren::sixin::account::MiscService* __del = dynamic_cast< ::IceDelegate::com::renren::sixin::account::MiscService*>(__delBase.get());
return __del->getAppVersion(userId, __ctx);
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__delBase, __ex, 0);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__delBase, __ex, 0, __cnt);
}
}
}
void
IceProxy::RoboCompGenericBase::GenericBase::getBasePose(::Ice::Int& x, ::Ice::Int& z, ::Ice::Float& alpha, const ::Ice::Context* __ctx)
{
::IceInternal::InvocationObserver __observer(this, __RoboCompGenericBase__GenericBase__getBasePose_name, __ctx);
int __cnt = 0;
while(true)
{
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
try
{
__checkTwowayOnly(__RoboCompGenericBase__GenericBase__getBasePose_name);
__delBase = __getDelegate(false);
::IceDelegate::RoboCompGenericBase::GenericBase* __del = dynamic_cast< ::IceDelegate::RoboCompGenericBase::GenericBase*>(__delBase.get());
__del->getBasePose(x, z, alpha, __ctx, __observer);
return;
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__delBase, __ex, __observer);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__delBase, __ex, true, __cnt, __observer);
}
}
}
::Factory::DevicePrx
IceProxy::Factory::DeviceFactory::query(const ::std::string& interfaceName, const ::Ice::Context* __ctx)
{
int __cnt = 0;
while(true)
{
::IceInternal::RequestHandlerPtr __handler;
try
{
__checkTwowayOnly(__Factory__DeviceFactory__query_name);
__handler = __getRequestHandler();
::IceInternal::Outgoing __outS(__handler.get(), _reference.get(), __Factory__DeviceFactory__query_name, ::Ice::Normal, __ctx);
try
{
::IceInternal::BasicStream* __os = __outS.os();
__os->write(interfaceName);
}
catch(const ::Ice::LocalException& __ex)
{
__outS.abort(__ex);
}
bool __ok = __outS.invoke();
try
{
if(!__ok)
{
__outS.is()->throwUnknownUserException();
}
::Factory::DevicePrx __ret;
::IceInternal::BasicStream* __is = __outS.is();
::Factory::__read(__is, __ret);
return __ret;
}
catch(const ::Ice::LocalException& __ex)
{
throw ::IceInternal::LocalExceptionWrapper(__ex, false);
}
#if defined(_MSC_VER) && defined(_M_ARM) // ARM bug.
catch(...)
{
throw;
}
#endif
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__handler, __ex);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__handler, __ex, __cnt);
}
#if defined(_MSC_VER) && defined(_M_ARM) // ARM bug.
catch(...)
{
throw;
}
#endif
}
}
void
IceProxy::OWSMODULE::DataOperation::CheckState(const ::std::string& taskID, ::OWSMODULE::OWSTask& task, const ::Ice::Context* __ctx)
{
::IceInternal::InvocationObserver __observer(this, __OWSMODULE__DataOperation__CheckState_name, __ctx);
int __cnt = 0;
while(true)
{
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
try
{
__checkTwowayOnly(__OWSMODULE__DataOperation__CheckState_name);
__delBase = __getDelegate(false);
::IceDelegate::OWSMODULE::DataOperation* __del = dynamic_cast< ::IceDelegate::OWSMODULE::DataOperation*>(__delBase.get());
__del->CheckState(taskID, task, __ctx, __observer);
return;
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__delBase, __ex, __observer);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__delBase, __ex, true, __cnt, __observer);
}
}
}
::level1::level2::viviPtr
IceProxy::level1::level2::test::output(const ::level1::level2::cocoPtr& c, const ::Ice::Context* __ctx)
{
int __cnt = 0;
while(true)
{
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
try
{
#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
IceUtil::DummyBCC dummy;
#endif
__checkTwowayOnly(__level1__level2__test__output_name);
__delBase = __getDelegate(false);
::IceDelegate::level1::level2::test* __del = dynamic_cast< ::IceDelegate::level1::level2::test*>(__delBase.get());
return __del->output(c, __ctx);
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__delBase, __ex, 0);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__delBase, __ex, 0, __cnt);
}
}
}
::Ice::Int
IceProxy::MCal::Cal::sub(::Ice::Int num1, ::Ice::Int num2, const ::Ice::Context* __ctx)
{
::IceInternal::InvocationObserver __observer(this, __MCal__Cal__sub_name, __ctx);
int __cnt = 0;
while(true)
{
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
try
{
__checkTwowayOnly(__MCal__Cal__sub_name);
__delBase = __getDelegate(false);
::IceDelegate::MCal::Cal* __del = dynamic_cast< ::IceDelegate::MCal::Cal*>(__delBase.get());
return __del->sub(num1, num2, __ctx, __observer);
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__delBase, __ex, __observer);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__delBase, __ex, true, __cnt, __observer);
}
}
}
::UC3M::consultasesion
IceProxy::UC3M::CineTicketService::consulta(::Ice::Int horaSesion, const ::Ice::Context* __ctx)
{
::IceInternal::InvocationObserver __observer(this, __UC3M__CineTicketService__consulta_name, __ctx);
int __cnt = 0;
while(true)
{
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
try
{
__checkTwowayOnly(__UC3M__CineTicketService__consulta_name);
__delBase = __getDelegate(false);
::IceDelegate::UC3M::CineTicketService* __del = dynamic_cast< ::IceDelegate::UC3M::CineTicketService*>(__delBase.get());
return __del->consulta(horaSesion, __ctx, __observer);
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__delBase, __ex, __observer);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__delBase, __ex, true, __cnt, __observer);
}
}
}
::RoboCompGetAprilTags::listaMarcas
IceProxy::RoboCompGetAprilTags::GetAprilTags::checkMarcas(const ::Ice::Context* __ctx)
{
::IceInternal::InvocationObserver __observer(this, __RoboCompGetAprilTags__GetAprilTags__checkMarcas_name, __ctx);
int __cnt = 0;
while(true)
{
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
try
{
__checkTwowayOnly(__RoboCompGetAprilTags__GetAprilTags__checkMarcas_name);
__delBase = __getDelegate(false);
::IceDelegate::RoboCompGetAprilTags::GetAprilTags* __del = dynamic_cast< ::IceDelegate::RoboCompGetAprilTags::GetAprilTags*>(__delBase.get());
return __del->checkMarcas(__ctx, __observer);
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__delBase, __ex, __observer);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__delBase, __ex, true, __cnt, __observer);
}
}
}
::std::string
IceProxy::com::pera::base::runtime::remote::RobotRemoteService::runLocalRobotStart(const ::std::string& robotInfo, const ::Ice::Context* __ctx)
{
::IceInternal::InvocationObserver __observer(this, __com__pera__base__runtime__remote__RobotRemoteService__runLocalRobotStart_name, __ctx);
int __cnt = 0;
while(true)
{
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
try
{
__checkTwowayOnly(__com__pera__base__runtime__remote__RobotRemoteService__runLocalRobotStart_name);
__delBase = __getDelegate(false);
::IceDelegate::com::pera::base::runtime::remote::RobotRemoteService* __del = dynamic_cast< ::IceDelegate::com::pera::base::runtime::remote::RobotRemoteService*>(__delBase.get());
return __del->runLocalRobotStart(robotInfo, __ctx, __observer);
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__delBase, __ex, __observer);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__delBase, __ex, true, __cnt, __observer);
}
}
}
void
IceProxy::GlobalTable::DistributedMap::putNget(const ::std::string& s, const ::std::string& delta, ::std::string& counts, const ::Ice::Context* __ctx)
{
int __cnt = 0;
while(true)
{
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
try
{
__checkTwowayOnly(__GlobalTable__DistributedMap__putNget_name);
__delBase = __getDelegate(false);
::IceDelegate::GlobalTable::DistributedMap* __del = dynamic_cast< ::IceDelegate::GlobalTable::DistributedMap*>(__delBase.get());
__del->putNget(s, delta, counts, __ctx);
return;
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__delBase, __ex);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__delBase, __ex, true, __cnt);
}
}
}
::Temp::TimeInfoPrx
IceProxy::Temp::TimeInfo::getTimeInfo(const ::Ice::Context* __ctx)
{
int __cnt = 0;
while(true)
{
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
try
{
#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
IceUtil::DummyBCC dummy;
#endif
__checkTwowayOnly(__Temp__TimeInfo__getTimeInfo_name);
__delBase = __getDelegate(false);
::IceDelegate::Temp::TimeInfo* __del = dynamic_cast< ::IceDelegate::Temp::TimeInfo*>(__delBase.get());
return __del->getTimeInfo(__ctx);
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__delBase, __ex, 0);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__delBase, __ex, 0, __cnt);
}
}
}
bool
IceProxy::RoboCompPlanning::Planning::getNextAction(const ::std::string& Problem, ::RoboCompPlanning::Plan& solution, const ::Ice::Context* __ctx)
{
::IceInternal::InvocationObserver __observer(this, __RoboCompPlanning__Planning__getNextAction_name, __ctx);
int __cnt = 0;
while(true)
{
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
try
{
__checkTwowayOnly(__RoboCompPlanning__Planning__getNextAction_name);
__delBase = __getDelegate(false);
::IceDelegate::RoboCompPlanning::Planning* __del = dynamic_cast< ::IceDelegate::RoboCompPlanning::Planning*>(__delBase.get());
return __del->getNextAction(Problem, solution, __ctx, __observer);
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__delBase, __ex, __observer);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__delBase, __ex, true, __cnt, __observer);
}
}
}
::RoboCompCommonBehavior::ParameterList
IceProxy::RoboCompCommonBehavior::CommonBehavior::getParameterList(const ::Ice::Context* __ctx)
{
int __cnt = 0;
while(true)
{
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
try
{
#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
IceUtil::DummyBCC dummy;
#endif
__checkTwowayOnly(__RoboCompCommonBehavior__CommonBehavior__getParameterList_name);
__delBase = __getDelegate(false);
::IceDelegate::RoboCompCommonBehavior::CommonBehavior* __del = dynamic_cast< ::IceDelegate::RoboCompCommonBehavior::CommonBehavior*>(__delBase.get());
return __del->getParameterList(__ctx);
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__delBase, __ex, 0);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__delBase, __ex, 0, __cnt);
}
}
}
::UC3M::informacionSt
IceProxy::UC3M::AgendaService::ask(const ::Ice::Context* __ctx)
{
::IceInternal::InvocationObserver __observer(this, __UC3M__AgendaService__ask_name, __ctx);
int __cnt = 0;
while(true)
{
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
try
{
__checkTwowayOnly(__UC3M__AgendaService__ask_name);
__delBase = __getDelegate(false);
::IceDelegate::UC3M::AgendaService* __del = dynamic_cast< ::IceDelegate::UC3M::AgendaService*>(__delBase.get());
return __del->ask(__ctx, __observer);
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__delBase, __ex, __observer);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__delBase, __ex, true, __cnt, __observer);
}
}
}
::Ice::Int
IceProxy::CoreSpace::CoreBase::add(::Ice::Int a, ::Ice::Int b, const ::Ice::Context* __ctx)
{
::IceInternal::InvocationObserver __observer(this, __CoreSpace__CoreBase__add_name, __ctx);
int __cnt = 0;
while(true)
{
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
try
{
__checkTwowayOnly(__CoreSpace__CoreBase__add_name);
__delBase = __getDelegate(false);
::IceDelegate::CoreSpace::CoreBase* __del = dynamic_cast< ::IceDelegate::CoreSpace::CoreBase*>(__delBase.get());
return __del->add(a, b, __ctx, __observer);
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__delBase, __ex, __observer);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__delBase, __ex, true, __cnt, __observer);
}
}
}
::Factory::TStringArray
IceProxy::Factory::DeviceFactory::interfaces(const ::Ice::Context* __ctx)
{
int __cnt = 0;
while(true)
{
::IceInternal::RequestHandlerPtr __handler;
try
{
__checkTwowayOnly(__Factory__DeviceFactory__interfaces_name);
__handler = __getRequestHandler();
::IceInternal::Outgoing __outS(__handler.get(), _reference.get(), __Factory__DeviceFactory__interfaces_name, ::Ice::Idempotent, __ctx);
bool __ok = __outS.invoke();
try
{
if(!__ok)
{
__outS.is()->throwUnknownUserException();
}
::Factory::TStringArray __ret;
::IceInternal::BasicStream* __is = __outS.is();
__is->read(__ret);
return __ret;
}
catch(const ::Ice::LocalException& __ex)
{
throw ::IceInternal::LocalExceptionWrapper(__ex, false);
}
#if defined(_MSC_VER) && defined(_M_ARM) // ARM bug.
catch(...)
{
throw;
}
#endif
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapperRelaxed(__handler, __ex, __cnt);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__handler, __ex, __cnt);
}
#if defined(_MSC_VER) && defined(_M_ARM) // ARM bug.
catch(...)
{
throw;
}
#endif
}
}
::Client::CCamPrx
IceProxy::Client::CClient::cam(const ::Ice::Context* __ctx)
{
int __cnt = 0;
while(true)
{
::IceInternal::RequestHandlerPtr __handler;
try
{
__checkTwowayOnly(__Client__CClient__cam_name);
__handler = __getRequestHandler();
::IceInternal::Outgoing __outS(__handler.get(), _reference.get(), __Client__CClient__cam_name, ::Ice::Normal, __ctx);
bool __ok = __outS.invoke();
try
{
if(!__ok)
{
__outS.is()->throwUnknownUserException();
}
::Client::CCamPrx __ret;
::IceInternal::BasicStream* __is = __outS.is();
::Client::__read(__is, __ret);
return __ret;
}
catch(const ::Ice::LocalException& __ex)
{
throw ::IceInternal::LocalExceptionWrapper(__ex, false);
}
#if defined(_MSC_VER) && defined(_M_ARM) // ARM bug.
catch(...)
{
throw;
}
#endif
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__handler, __ex);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__handler, __ex, __cnt);
}
#if defined(_MSC_VER) && defined(_M_ARM) // ARM bug.
catch(...)
{
throw;
}
#endif
}
}
::std::string
IceProxy::tfs::slice::Transfer::getLocalPath(::Ice::Long chunkid, const ::Ice::Context& __ctx)
{
int __cnt = 0;
while(true)
{
try
{
__checkTwowayOnly(__tfs__slice__Transfer__getLocalPath_name);
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase = __getDelegate();
::IceDelegate::tfs::slice::Transfer* __del = dynamic_cast< ::IceDelegate::tfs::slice::Transfer*>(__delBase.get());
return __del->getLocalPath(chunkid, __ctx);
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__ex);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__ex, __cnt);
}
}
}
::Ice::Int
IceProxy::tfs::slice::Transfer::write(::Ice::Long chunkid, const ::tfs::slice::ByteSeq& bytes, ::Ice::Int offset, ::Ice::Int len, const ::Ice::Context& __ctx)
{
int __cnt = 0;
while(true)
{
try
{
__checkTwowayOnly(__tfs__slice__Transfer__write_name);
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase = __getDelegate();
::IceDelegate::tfs::slice::Transfer* __del = dynamic_cast< ::IceDelegate::tfs::slice::Transfer*>(__delBase.get());
return __del->write(chunkid, bytes, offset, len, __ctx);
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__ex);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__ex, __cnt);
}
}
}
::std::string IceProxy::zerocexample::MessageIce::getContent(const ::Ice::Context* __ctx)
{
__checkTwowayOnly(__zerocexample__MessageIce__getContent_name);
::IceInternal::Outgoing __og(this, __zerocexample__MessageIce__getContent_name, ::Ice::Idempotent, __ctx);
__og.writeEmptyParams();
if (!__og.invoke())
{
try
{
__og.throwUserException();
}
catch (const ::Ice::UserException& __ex)
{
::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
throw __uue;
}
}
::std::string __ret;
::IceInternal::BasicStream* __is = __og.startReadParams();
__is->read(__ret);
__og.endReadParams();
return __ret;
}
::Ice::Int
IceProxy::loggerice::loggerctrl::Register(const ::std::string& name, const ::Ice::Context* __ctx)
{
int __cnt = 0;
while(true)
{
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
try
{
__checkTwowayOnly(__loggerice__loggerctrl__Register_name);
__delBase = __getDelegate(false);
::IceDelegate::loggerice::loggerctrl* __del = dynamic_cast< ::IceDelegate::loggerice::loggerctrl*>(__delBase.get());
return __del->Register(name, __ctx);
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__delBase, __ex);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__delBase, __ex, true, __cnt);
}
}
}
::std::string
IceProxy::HSFoward::HSBnsProc::amdfun(::Ice::Int num, const ::std::string& str, const ::Ice::Context* __ctx)
{
int __cnt = 0;
while(true)
{
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
try
{
__checkTwowayOnly(__HSFoward__HSBnsProc__amdfun_name);
__delBase = __getDelegate(false);
::IceDelegate::HSFoward::HSBnsProc* __del = dynamic_cast< ::IceDelegate::HSFoward::HSBnsProc*>(__delBase.get());
return __del->amdfun(num, str, __ctx);
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__delBase, __ex);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__delBase, __ex, true, __cnt);
}
}
}
::std::string
IceProxy::ICSSW::Component::getName(const ::Ice::Context* __ctx)
{
int __cnt = 0;
while(true)
{
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
try
{
__checkTwowayOnly(__ICSSW__Component__getName_name);
__delBase = __getDelegate();
::IceDelegate::ICSSW::Component* __del = dynamic_cast< ::IceDelegate::ICSSW::Component*>(__delBase.get());
return __del->getName(__ctx);
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__delBase, __ex);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__delBase, __ex, __cnt);
}
}
}
::Ice::Int
IceProxy::MCS::MESLink::PlaceFoup(::Ice::Int foupBarCode, ::Ice::Int DevID, ::Ice::Int nLocType, const ::Ice::Context* __ctx)
{
int __cnt = 0;
while(true)
{
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
try
{
__checkTwowayOnly(__MCS__MESLink__PlaceFoup_name);
__delBase = __getDelegate(false);
::IceDelegate::MCS::MESLink* __del = dynamic_cast< ::IceDelegate::MCS::MESLink*>(__delBase.get());
return __del->PlaceFoup(foupBarCode, DevID, nLocType, __ctx);
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapperRelaxed(__delBase, __ex, true, __cnt);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__delBase, __ex, true, __cnt);
}
}
}
::orca::util::PingReplyData
IceProxy::orca::util::LatencyReplier::takeItAndReturn(const ::orca::util::PingReplyData& data, const ::Ice::Context* __ctx)
{
int __cnt = 0;
while(true)
{
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
try
{
__checkTwowayOnly(__orca__util__LatencyReplier__takeItAndReturn_name);
__delBase = __getDelegate();
::IceDelegate::orca::util::LatencyReplier* __del = dynamic_cast< ::IceDelegate::orca::util::LatencyReplier*>(__delBase.get());
return __del->takeItAndReturn(data, __ctx);
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__delBase, __ex);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__delBase, __ex, __cnt);
}
}
}
::BHAco::SDataPacket
IceProxy::BHAco::Request::RequestData(const ::BHAco::SDataPacket& dp, const ::Ice::Context* __ctx)
{
int __cnt = 0;
while(true)
{
::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
try
{
__checkTwowayOnly(__BHAco__Request__RequestData_name);
__delBase = __getDelegate();
::IceDelegate::BHAco::Request* __del = dynamic_cast< ::IceDelegate::BHAco::Request*>(__delBase.get());
return __del->RequestData(dp, __ctx);
}
catch(const ::IceInternal::LocalExceptionWrapper& __ex)
{
__handleExceptionWrapper(__delBase, __ex);
}
catch(const ::Ice::LocalException& __ex)
{
__handleException(__delBase, __ex, __cnt);
}
}
}
