::std::string
IceDelegateD::tfs::slice::Transfer::getLocalPath(::Ice::Long chunkid, const ::Ice::Context& __context)
{
::Ice::Current __current;
__initCurrent(__current, __tfs__slice__Transfer__getLocalPath_name, ::Ice::Normal, __context);
while(true)
{
::IceInternal::Direct __direct(__current);
::tfs::slice::Transfer* __servant = dynamic_cast< ::tfs::slice::Transfer*>(__direct.servant().get());
if(!__servant)
{
::Ice::OperationNotExistException __opEx(__FILE__, __LINE__);
__opEx.id = __current.id;
__opEx.facet = __current.facet;
__opEx.operation = __current.operation;
throw __opEx;
}
try
{
return __servant->getLocalPath(chunkid, __current);
}
catch(const ::Ice::LocalException& __ex)
{
throw ::IceInternal::LocalExceptionWrapper(__ex, false);
}
}
}
::BHAco::SDataPacket
IceDelegateD::BHAco::Request::RequestData(const ::BHAco::SDataPacket& dp, const ::Ice::Context* __context)
{
::Ice::Current __current;
__initCurrent(__current, __BHAco__Request__RequestData_name, ::Ice::Normal, __context);
while(true)
{
::IceInternal::Direct __direct(__current);
::BHAco::SDataPacket __ret;
try
{
::BHAco::Request* __servant = dynamic_cast< ::BHAco::Request*>(__direct.servant().get());
if(!__servant)
{
::Ice::OperationNotExistException __opEx(__FILE__, __LINE__);
__opEx.id = __current.id;
__opEx.facet = __current.facet;
__opEx.operation = __current.operation;
throw __opEx;
}
try
{
__ret = __servant->RequestData(dp, __current);
}
catch(const ::Ice::LocalException& __ex)
{
throw ::IceInternal::LocalExceptionWrapper(__ex, false);
}
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
return __ret;
}
}
::orca::util::PingReplyData
IceDelegateD::orca::util::LatencyReplier::takeItAndReturn(const ::orca::util::PingReplyData& data, const ::Ice::Context* __context)
{
::Ice::Current __current;
__initCurrent(__current, __orca__util__LatencyReplier__takeItAndReturn_name, ::Ice::Normal, __context);
while(true)
{
::IceInternal::Direct __direct(__current);
::orca::util::PingReplyData __ret;
try
{
::orca::util::LatencyReplier* __servant = dynamic_cast< ::orca::util::LatencyReplier*>(__direct.servant().get());
if(!__servant)
{
::Ice::OperationNotExistException __opEx(__FILE__, __LINE__);
__opEx.id = __current.id;
__opEx.facet = __current.facet;
__opEx.operation = __current.operation;
throw __opEx;
}
try
{
__ret = __servant->takeItAndReturn(data, __current);
}
catch(const ::Ice::LocalException& __ex)
{
throw ::IceInternal::LocalExceptionWrapper(__ex, false);
}
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
return __ret;
}
}
::std::string
IceDelegateD::ICSSW::Component::getName(const ::Ice::Context* __context)
{
::Ice::Current __current;
__initCurrent(__current, __ICSSW__Component__getName_name, ::Ice::Normal, __context);
while(true)
{
::IceInternal::Direct __direct(__current);
::std::string __ret;
try
{
::ICSSW::Component* __servant = dynamic_cast< ::ICSSW::Component*>(__direct.servant().get());
if(!__servant)
{
::Ice::OperationNotExistException __opEx(__FILE__, __LINE__);
__opEx.id = __current.id;
__opEx.facet = __current.facet;
__opEx.operation = __current.operation;
throw __opEx;
}
try
{
__ret = __servant->getName(__current);
}
catch(const ::Ice::LocalException& __ex)
{
throw ::IceInternal::LocalExceptionWrapper(__ex, false);
}
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
return __ret;
}
}
void
IceDelegateD::BHAco::Request::sayHello(::Ice::Int delay, const ::Ice::Context* __context)
{
::Ice::Current __current;
__initCurrent(__current, __BHAco__Request__sayHello_name, ::Ice::Idempotent, __context);
while(true)
{
::IceInternal::Direct __direct(__current);
try
{
::BHAco::Request* __servant = dynamic_cast< ::BHAco::Request*>(__direct.servant().get());
if(!__servant)
{
::Ice::OperationNotExistException __opEx(__FILE__, __LINE__);
__opEx.id = __current.id;
__opEx.facet = __current.facet;
__opEx.operation = __current.operation;
throw __opEx;
}
try
{
__servant->sayHello(delay, __current);
}
catch(const ::Ice::LocalException& __ex)
{
throw ::IceInternal::LocalExceptionWrapper(__ex, false);
}
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
return;
}
}
void
IceDelegateD::ICSSW::Notifier::notify(const ::ICSSW::Event& ev, const ::Ice::Context* __context)
{
::Ice::Current __current;
__initCurrent(__current, __ICSSW__Notifier__notify_name, ::Ice::Normal, __context);
while(true)
{
::IceInternal::Direct __direct(__current);
try
{
::ICSSW::Notifier* __servant = dynamic_cast< ::ICSSW::Notifier*>(__direct.servant().get());
if(!__servant)
{
::Ice::OperationNotExistException __opEx(__FILE__, __LINE__);
__opEx.id = __current.id;
__opEx.facet = __current.facet;
__opEx.operation = __current.operation;
throw __opEx;
}
try
{
__servant->notify(ev, __current);
}
catch(const ::Ice::LocalException& __ex)
{
throw ::IceInternal::LocalExceptionWrapper(__ex, false);
}
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
return;
}
}
void
IceDelegateD::orca::util::LatencyReplier::setPinger(const ::orca::util::LatencyPingerPrx& server, const ::Ice::Context* __context)
{
::Ice::Current __current;
__initCurrent(__current, __orca__util__LatencyReplier__setPinger_name, ::Ice::Idempotent, __context);
while(true)
{
::IceInternal::Direct __direct(__current);
try
{
::orca::util::LatencyReplier* __servant = dynamic_cast< ::orca::util::LatencyReplier*>(__direct.servant().get());
if(!__servant)
{
::Ice::OperationNotExistException __opEx(__FILE__, __LINE__);
__opEx.id = __current.id;
__opEx.facet = __current.facet;
__opEx.operation = __current.operation;
throw __opEx;
}
try
{
__servant->setPinger(server, __current);
}
catch(const ::Ice::LocalException& __ex)
{
throw ::IceInternal::LocalExceptionWrapper(__ex, false);
}
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
return;
}
}
::Temp::TimeInfoPrx
IceDelegateD::Temp::TimeInfo::getTimeInfo(const ::Ice::Context* __context)
{
class _DirectI : public ::IceInternal::Direct
{
public:
_DirectI(::Temp::TimeInfoPrx& __result, const ::Ice::Current& __current) :
::IceInternal::Direct(__current),
_result(__result)
{
}
virtual ::Ice::DispatchStatus
run(::Ice::Object* object)
{
::Temp::TimeInfo* servant = dynamic_cast< ::Temp::TimeInfo*>(object);
if(!servant)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
}
_result = servant->getTimeInfo(_current);
return ::Ice::DispatchOK;
}
private:
::Temp::TimeInfoPrx& _result;
};
::Ice::Current __current;
__initCurrent(__current, __Temp__TimeInfo__getTimeInfo_name, ::Ice::Normal, __context);
::Temp::TimeInfoPrx __result;
try
{
_DirectI __direct(__result, __current);
try
{
__direct.servant()->__collocDispatch(__direct);
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
}
catch(const ::Ice::SystemException&)
{
throw;
}
catch(const ::IceInternal::LocalExceptionWrapper&)
{
throw;
}
catch(const ::std::exception& __ex)
{
::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
}
catch(...)
{
throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
}
return __result;
}
void
IceDelegateD::loggerice::loggerctrl::SetThreadName(::Ice::Int regid, ::Ice::Long threadid, const ::std::string& name, const ::Ice::Context* __context)
{
class _DirectI : public ::IceInternal::Direct
{
public:
_DirectI(::Ice::Int regid, ::Ice::Long threadid, const ::std::string& name, const ::Ice::Current& __current) :
::IceInternal::Direct(__current),
_m_regid(regid),
_m_threadid(threadid),
_m_name(name)
{
}
virtual ::Ice::DispatchStatus
run(::Ice::Object* object)
{
::loggerice::loggerctrl* servant = dynamic_cast< ::loggerice::loggerctrl*>(object);
if(!servant)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
}
servant->SetThreadName(_m_regid, _m_threadid, _m_name, _current);
return ::Ice::DispatchOK;
}
private:
::Ice::Int _m_regid;
::Ice::Long _m_threadid;
const ::std::string& _m_name;
};
::Ice::Current __current;
__initCurrent(__current, __loggerice__loggerctrl__SetThreadName_name, ::Ice::Normal, __context);
try
{
_DirectI __direct(regid, threadid, name, __current);
try
{
__direct.servant()->__collocDispatch(__direct);
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
}
catch(const ::Ice::SystemException&)
{
throw;
}
catch(const ::IceInternal::LocalExceptionWrapper&)
{
throw;
}
catch(const ::std::exception& __ex)
{
::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
}
catch(...)
{
throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
}
}
void
IceDelegateD::jderobot::Quadrotor::toggleCam(const ::Ice::Context* __context)
{
class _DirectI : public ::IceInternal::Direct
{
public:
_DirectI(const ::Ice::Current& __current) :
::IceInternal::Direct(__current)
{
}
virtual ::Ice::DispatchStatus
run(::Ice::Object* object)
{
::jderobot::Quadrotor* servant = dynamic_cast< ::jderobot::Quadrotor*>(object);
if(!servant)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
}
servant->toggleCam(_current);
return ::Ice::DispatchOK;
}
private:
};
::Ice::Current __current;
__initCurrent(__current, __jderobot__Quadrotor__toggleCam_name, ::Ice::Normal, __context);
try
{
_DirectI __direct(__current);
try
{
__direct.servant()->__collocDispatch(__direct);
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
}
catch(const ::Ice::SystemException&)
{
throw;
}
catch(const ::IceInternal::LocalExceptionWrapper&)
{
throw;
}
catch(const ::std::exception& __ex)
{
::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
}
catch(...)
{
throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
}
}
::MCS::LocFoup
IceDelegateD::MCS::MESLink::GetFoup(::Ice::Int foupBarCode, const ::Ice::Context* __context)
{
class _DirectI : public ::IceInternal::Direct
{
public:
_DirectI(::MCS::LocFoup& __result, ::Ice::Int foupBarCode, const ::Ice::Current& __current) :
::IceInternal::Direct(__current),
_result(__result),
_m_foupBarCode(foupBarCode)
{
}
virtual ::Ice::DispatchStatus
run(::Ice::Object* object)
{
::MCS::MESLink* servant = dynamic_cast< ::MCS::MESLink*>(object);
if(!servant)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
}
_result = servant->GetFoup(_m_foupBarCode, _current);
return ::Ice::DispatchOK;
}
private:
::MCS::LocFoup& _result;
::Ice::Int _m_foupBarCode;
};
::Ice::Current __current;
__initCurrent(__current, __MCS__MESLink__GetFoup_name, ::Ice::Idempotent, __context);
::MCS::LocFoup __result;
try
{
_DirectI __direct(__result, foupBarCode, __current);
try
{
__direct.servant()->__collocDispatch(__direct);
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
}
catch(const ::Ice::SystemException&)
{
throw;
}
catch(const ::IceInternal::LocalExceptionWrapper&)
{
throw;
}
catch(const ::std::exception& __ex)
{
::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
}
catch(...)
{
throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
}
return __result;
}
::Ice::Int
IceDelegateD::CoreSpace::CoreBase::sub(::Ice::Int a, ::Ice::Int b, const ::Ice::Context* __context, ::IceInternal::InvocationObserver&)
{
class _DirectI : public ::IceInternal::Direct
{
public:
_DirectI(::Ice::Int& __result, ::Ice::Int __p_a, ::Ice::Int __p_b, const ::Ice::Current& __current) :
::IceInternal::Direct(__current),
_result(__result),
_m_a(__p_a),
_m_b(__p_b)
{
}
virtual ::Ice::DispatchStatus
run(::Ice::Object* object)
{
::CoreSpace::CoreBase* servant = dynamic_cast< ::CoreSpace::CoreBase*>(object);
if(!servant)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
}
_result = servant->sub(_m_a, _m_b, _current);
return ::Ice::DispatchOK;
}
private:
::Ice::Int& _result;
::Ice::Int _m_a;
::Ice::Int _m_b;
};
::Ice::Current __current;
__initCurrent(__current, __CoreSpace__CoreBase__sub_name, ::Ice::Normal, __context);
::Ice::Int __result;
try
{
_DirectI __direct(__result, a, b, __current);
try
{
__direct.getServant()->__collocDispatch(__direct);
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
}
catch(const ::Ice::SystemException&)
{
throw;
}
catch(const ::IceInternal::LocalExceptionWrapper&)
{
throw;
}
catch(const ::std::exception& __ex)
{
::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
}
catch(...)
{
throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
}
return __result;
}
::Ice::Int
IceDelegateD::HSFoward::HSBnsProc::fun(::Ice::Int num, const ::std::string& str, const ::Ice::Context* __context)
{
class _DirectI : public ::IceInternal::Direct
{
public:
_DirectI(::Ice::Int& __result, ::Ice::Int num, const ::std::string& str, const ::Ice::Current& __current) :
::IceInternal::Direct(__current),
_result(__result),
_m_num(num),
_m_str(str)
{
}
virtual ::Ice::DispatchStatus
run(::Ice::Object* object)
{
::HSFoward::HSBnsProc* servant = dynamic_cast< ::HSFoward::HSBnsProc*>(object);
if(!servant)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
}
_result = servant->fun(_m_num, _m_str, _current);
return ::Ice::DispatchOK;
}
private:
::Ice::Int& _result;
::Ice::Int _m_num;
const ::std::string& _m_str;
};
::Ice::Current __current;
__initCurrent(__current, __HSFoward__HSBnsProc__fun_name, ::Ice::Normal, __context);
::Ice::Int __result;
try
{
_DirectI __direct(__result, num, str, __current);
try
{
__direct.servant()->__collocDispatch(__direct);
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
}
catch(const ::Ice::SystemException&)
{
throw;
}
catch(const ::IceInternal::LocalExceptionWrapper&)
{
throw;
}
catch(const ::std::exception& __ex)
{
::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
}
catch(...)
{
throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
}
return __result;
}
void
IceDelegateD::RoboCompGenericBase::GenericBase::getBasePose(::Ice::Int& x, ::Ice::Int& z, ::Ice::Float& alpha, const ::Ice::Context* __context, ::IceInternal::InvocationObserver&)
{
class _DirectI : public ::IceInternal::Direct
{
public:
_DirectI(::Ice::Int& __p_x, ::Ice::Int& __p_z, ::Ice::Float& __p_alpha, const ::Ice::Current& __current) :
::IceInternal::Direct(__current),
_m_x(__p_x),
_m_z(__p_z),
_m_alpha(__p_alpha)
{
}
virtual ::Ice::DispatchStatus
run(::Ice::Object* object)
{
::RoboCompGenericBase::GenericBase* servant = dynamic_cast< ::RoboCompGenericBase::GenericBase*>(object);
if(!servant)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
}
try
{
servant->getBasePose(_m_x, _m_z, _m_alpha, _current);
return ::Ice::DispatchOK;
}
catch(const ::Ice::UserException& __ex)
{
setUserException(__ex);
return ::Ice::DispatchUserException;
}
}
private:
::Ice::Int& _m_x;
::Ice::Int& _m_z;
::Ice::Float& _m_alpha;
};
::Ice::Current __current;
__initCurrent(__current, __RoboCompGenericBase__GenericBase__getBasePose_name, ::Ice::Normal, __context);
try
{
_DirectI __direct(x, z, alpha, __current);
try
{
__direct.getServant()->__collocDispatch(__direct);
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
}
catch(const ::RoboCompGenericBase::HardwareFailedException&)
{
throw;
}
catch(const ::Ice::SystemException&)
{
throw;
}
catch(const ::IceInternal::LocalExceptionWrapper&)
{
throw;
}
catch(const ::std::exception& __ex)
{
::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
}
catch(...)
{
throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
}
}
void
IceDelegateD::OWSMODULE::DataOperation::shutdown(const ::Ice::Context* __context, ::IceInternal::InvocationObserver&)
{
class _DirectI : public ::IceInternal::Direct
{
public:
_DirectI(const ::Ice::Current& __current) :
::IceInternal::Direct(__current)
{
}
virtual ::Ice::DispatchStatus
run(::Ice::Object* object)
{
::OWSMODULE::DataOperation* servant = dynamic_cast< ::OWSMODULE::DataOperation*>(object);
if(!servant)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
}
servant->shutdown(_current);
return ::Ice::DispatchOK;
}
private:
};
::Ice::Current __current;
__initCurrent(__current, __OWSMODULE__DataOperation__shutdown_name, ::Ice::Normal, __context);
try
{
_DirectI __direct(__current);
try
{
__direct.getServant()->__collocDispatch(__direct);
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
}
catch(const ::Ice::SystemException&)
{
throw;
}
catch(const ::IceInternal::LocalExceptionWrapper&)
{
throw;
}
catch(const ::std::exception& __ex)
{
::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
}
catch(...)
{
throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
}
}
::Ice::Int
IceDelegateD::UC3M::CineTicketService::cancela(::Ice::Int horaSesion, ::Ice::Int numeroButaca, const ::Ice::Context* __context, ::IceInternal::InvocationObserver&)
{
class _DirectI : public ::IceInternal::Direct
{
public:
_DirectI(::Ice::Int& __result, ::Ice::Int __p_horaSesion, ::Ice::Int __p_numeroButaca, const ::Ice::Current& __current) :
::IceInternal::Direct(__current),
_result(__result),
_m_horaSesion(__p_horaSesion),
_m_numeroButaca(__p_numeroButaca)
{
}
virtual ::Ice::DispatchStatus
run(::Ice::Object* object)
{
::UC3M::CineTicketService* servant = dynamic_cast< ::UC3M::CineTicketService*>(object);
if(!servant)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
}
_result = servant->cancela(_m_horaSesion, _m_numeroButaca, _current);
return ::Ice::DispatchOK;
}
private:
::Ice::Int& _result;
::Ice::Int _m_horaSesion;
::Ice::Int _m_numeroButaca;
};
::Ice::Current __current;
__initCurrent(__current, __UC3M__CineTicketService__cancela_name, ::Ice::Normal, __context);
::Ice::Int __result;
try
{
_DirectI __direct(__result, horaSesion, numeroButaca, __current);
try
{
__direct.getServant()->__collocDispatch(__direct);
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
}
catch(const ::Ice::SystemException&)
{
throw;
}
catch(const ::IceInternal::LocalExceptionWrapper&)
{
throw;
}
catch(const ::std::exception& __ex)
{
::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
}
catch(...)
{
throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
}
return __result;
}
::Ice::Int
IceDelegateD::RoboCompCommonBehavior::CommonBehavior::timeAwake(const ::Ice::Context* __context)
{
class _DirectI : public ::IceInternal::Direct
{
public:
_DirectI(::Ice::Int& __result, const ::Ice::Current& __current) :
::IceInternal::Direct(__current),
_result(__result)
{
}
virtual ::Ice::DispatchStatus
run(::Ice::Object* object)
{
::RoboCompCommonBehavior::CommonBehavior* servant = dynamic_cast< ::RoboCompCommonBehavior::CommonBehavior*>(object);
if(!servant)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
}
_result = servant->timeAwake(_current);
return ::Ice::DispatchOK;
}
private:
::Ice::Int& _result;
};
::Ice::Current __current;
__initCurrent(__current, __RoboCompCommonBehavior__CommonBehavior__timeAwake_name, ::Ice::Idempotent, __context);
::Ice::Int __result;
try
{
_DirectI __direct(__result, __current);
try
{
__direct.servant()->__collocDispatch(__direct);
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
}
catch(const ::Ice::SystemException&)
{
throw;
}
catch(const ::IceInternal::LocalExceptionWrapper&)
{
throw;
}
catch(const ::std::exception& __ex)
{
::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
}
catch(...)
{
throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
}
return __result;
}
::com::renren::sixin::account::VersionResultPtr
IceDelegateD::com::renren::sixin::account::MiscService::getAppVersion(::Ice::Long userId, const ::Ice::Context* __context)
{
class _DirectI : public ::IceInternal::Direct
{
public:
_DirectI(::com::renren::sixin::account::VersionResultPtr& __result, ::Ice::Long userId, const ::Ice::Current& __current) :
::IceInternal::Direct(__current),
_result(__result),
_m_userId(userId)
{
}
virtual ::Ice::DispatchStatus
run(::Ice::Object* object)
{
::com::renren::sixin::account::MiscService* servant = dynamic_cast< ::com::renren::sixin::account::MiscService*>(object);
if(!servant)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
}
_result = servant->getAppVersion(_m_userId, _current);
return ::Ice::DispatchOK;
}
private:
::com::renren::sixin::account::VersionResultPtr& _result;
::Ice::Long _m_userId;
};
::Ice::Current __current;
__initCurrent(__current, __com__renren__sixin__account__MiscService__getAppVersion_name, ::Ice::Normal, __context);
::com::renren::sixin::account::VersionResultPtr __result;
try
{
_DirectI __direct(__result, userId, __current);
try
{
__direct.servant()->__collocDispatch(__direct);
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
}
catch(const ::Ice::SystemException&)
{
throw;
}
catch(const ::IceInternal::LocalExceptionWrapper&)
{
throw;
}
catch(const ::std::exception& __ex)
{
::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
}
catch(...)
{
throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
}
return __result;
}
void
IceDelegateD::com::renren::sixin::account::MiscService::syncRenrenAccount(::Ice::Int renrenUid, ::Ice::Int appId, ::Ice::Int callerType, const ::Ice::Context* __context)
{
class _DirectI : public ::IceInternal::Direct
{
public:
_DirectI(::Ice::Int renrenUid, ::Ice::Int appId, ::Ice::Int callerType, const ::Ice::Current& __current) :
::IceInternal::Direct(__current),
_m_renrenUid(renrenUid),
_m_appId(appId),
_m_callerType(callerType)
{
}
virtual ::Ice::DispatchStatus
run(::Ice::Object* object)
{
::com::renren::sixin::account::MiscService* servant = dynamic_cast< ::com::renren::sixin::account::MiscService*>(object);
if(!servant)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
}
servant->syncRenrenAccount(_m_renrenUid, _m_appId, _m_callerType, _current);
return ::Ice::DispatchOK;
}
private:
::Ice::Int _m_renrenUid;
::Ice::Int _m_appId;
::Ice::Int _m_callerType;
};
::Ice::Current __current;
__initCurrent(__current, __com__renren__sixin__account__MiscService__syncRenrenAccount_name, ::Ice::Normal, __context);
try
{
_DirectI __direct(renrenUid, appId, callerType, __current);
try
{
__direct.servant()->__collocDispatch(__direct);
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
}
catch(const ::Ice::SystemException&)
{
throw;
}
catch(const ::IceInternal::LocalExceptionWrapper&)
{
throw;
}
catch(const ::std::exception& __ex)
{
::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
}
catch(...)
{
throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
}
}
::std::string
IceDelegateD::com::pera::base::runtime::remote::RobotRemoteService::runLocalRobotStart(const ::std::string& robotInfo, const ::Ice::Context* __context, ::IceInternal::InvocationObserver&)
{
class _DirectI : public ::IceInternal::Direct
{
public:
_DirectI(::std::string& __result, const ::std::string& __p_robotInfo, const ::Ice::Current& __current) :
::IceInternal::Direct(__current),
_result(__result),
_m_robotInfo(__p_robotInfo)
{
}
virtual ::Ice::DispatchStatus
run(::Ice::Object* object)
{
::com::pera::base::runtime::remote::RobotRemoteService* servant = dynamic_cast< ::com::pera::base::runtime::remote::RobotRemoteService*>(object);
if(!servant)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
}
try
{
_result = servant->runLocalRobotStart(_m_robotInfo, _current);
return ::Ice::DispatchOK;
}
catch(const ::Ice::UserException& __ex)
{
setUserException(__ex);
return ::Ice::DispatchUserException;
}
}
private:
::std::string& _result;
const ::std::string& _m_robotInfo;
};
::Ice::Current __current;
__initCurrent(__current, __com__pera__base__runtime__remote__RobotRemoteService__runLocalRobotStart_name, ::Ice::Normal, __context);
::std::string __result;
try
{
_DirectI __direct(__result, robotInfo, __current);
try
{
__direct.getServant()->__collocDispatch(__direct);
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
}
catch(const ::com::pera::base::runtime::remote::RemoteException&)
{
throw;
}
catch(const ::Ice::SystemException&)
{
throw;
}
catch(const ::IceInternal::LocalExceptionWrapper&)
{
throw;
}
catch(const ::std::exception& __ex)
{
::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
}
catch(...)
{
throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
}
return __result;
}
::RoboCompGetAprilTags::listaMarcas
IceDelegateD::RoboCompGetAprilTags::GetAprilTags::checkMarcas(const ::Ice::Context* __context, ::IceInternal::InvocationObserver&)
{
class _DirectI : public ::IceInternal::Direct
{
public:
_DirectI(::RoboCompGetAprilTags::listaMarcas& __result, const ::Ice::Current& __current) :
::IceInternal::Direct(__current),
_result(__result)
{
}
virtual ::Ice::DispatchStatus
run(::Ice::Object* object)
{
::RoboCompGetAprilTags::GetAprilTags* servant = dynamic_cast< ::RoboCompGetAprilTags::GetAprilTags*>(object);
if(!servant)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
}
_result = servant->checkMarcas(_current);
return ::Ice::DispatchOK;
}
private:
::RoboCompGetAprilTags::listaMarcas& _result;
};
::Ice::Current __current;
__initCurrent(__current, __RoboCompGetAprilTags__GetAprilTags__checkMarcas_name, ::Ice::Normal, __context);
::RoboCompGetAprilTags::listaMarcas __result;
try
{
_DirectI __direct(__result, __current);
try
{
__direct.getServant()->__collocDispatch(__direct);
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
}
catch(const ::Ice::SystemException&)
{
throw;
}
catch(const ::IceInternal::LocalExceptionWrapper&)
{
throw;
}
catch(const ::std::exception& __ex)
{
::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
}
catch(...)
{
throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
}
return __result;
}
void
IceDelegateD::RoboCompCommonBehavior::CommonBehavior::setParameterList(const ::RoboCompCommonBehavior::ParameterList& l, const ::Ice::Context* __context)
{
class _DirectI : public ::IceInternal::Direct
{
public:
_DirectI(const ::RoboCompCommonBehavior::ParameterList& l, const ::Ice::Current& __current) :
::IceInternal::Direct(__current),
_m_l(l)
{
}
virtual ::Ice::DispatchStatus
run(::Ice::Object* object)
{
::RoboCompCommonBehavior::CommonBehavior* servant = dynamic_cast< ::RoboCompCommonBehavior::CommonBehavior*>(object);
if(!servant)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
}
servant->setParameterList(_m_l, _current);
return ::Ice::DispatchOK;
}
private:
const ::RoboCompCommonBehavior::ParameterList& _m_l;
};
::Ice::Current __current;
__initCurrent(__current, __RoboCompCommonBehavior__CommonBehavior__setParameterList_name, ::Ice::Normal, __context);
try
{
_DirectI __direct(l, __current);
try
{
__direct.servant()->__collocDispatch(__direct);
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
}
catch(const ::Ice::SystemException&)
{
throw;
}
catch(const ::IceInternal::LocalExceptionWrapper&)
{
throw;
}
catch(const ::std::exception& __ex)
{
::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
}
catch(...)
{
throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
}
}
::Ice::Int
IceDelegateD::OWSMODULE::DataOperation::ReadData(const ::std::string& taskID, ::OWSMODULE::byteSeq& DataBlock, const ::Ice::Context* __context, ::IceInternal::InvocationObserver&)
{
class _DirectI : public ::IceInternal::Direct
{
public:
_DirectI(::Ice::Int& __result, const ::std::string& __p_taskID, ::OWSMODULE::byteSeq& __p_DataBlock, const ::Ice::Current& __current) :
::IceInternal::Direct(__current),
_result(__result),
_m_taskID(__p_taskID),
_m_DataBlock(__p_DataBlock)
{
}
virtual ::Ice::DispatchStatus
run(::Ice::Object* object)
{
::OWSMODULE::DataOperation* servant = dynamic_cast< ::OWSMODULE::DataOperation*>(object);
if(!servant)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
}
_result = servant->ReadData(_m_taskID, _m_DataBlock, _current);
return ::Ice::DispatchOK;
}
private:
::Ice::Int& _result;
const ::std::string& _m_taskID;
::OWSMODULE::byteSeq& _m_DataBlock;
};
::Ice::Current __current;
__initCurrent(__current, __OWSMODULE__DataOperation__ReadData_name, ::Ice::Normal, __context);
::Ice::Int __result;
try
{
_DirectI __direct(__result, taskID, DataBlock, __current);
try
{
__direct.getServant()->__collocDispatch(__direct);
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
}
catch(const ::Ice::SystemException&)
{
throw;
}
catch(const ::IceInternal::LocalExceptionWrapper&)
{
throw;
}
catch(const ::std::exception& __ex)
{
::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
}
catch(...)
{
throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
}
return __result;
}
void
IceDelegateD::com::xiaonei::wap::push::disturb::disturbService4Sixin::setDisturbTime(::Ice::Long userId, ::Ice::Int appType, ::Ice::Long uploadTime, const ::std::string& startTime, const ::std::string& endTime, const ::Ice::Context* __context)
{
class _DirectI : public ::IceInternal::Direct
{
public:
_DirectI(::Ice::Long userId, ::Ice::Int appType, ::Ice::Long uploadTime, const ::std::string& startTime, const ::std::string& endTime, const ::Ice::Current& __current) :
::IceInternal::Direct(__current),
_m_userId(userId),
_m_appType(appType),
_m_uploadTime(uploadTime),
_m_startTime(startTime),
_m_endTime(endTime)
{
}
virtual ::Ice::DispatchStatus
run(::Ice::Object* object)
{
::com::xiaonei::wap::push::disturb::disturbService4Sixin* servant = dynamic_cast< ::com::xiaonei::wap::push::disturb::disturbService4Sixin*>(object);
if(!servant)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
}
servant->setDisturbTime(_m_userId, _m_appType, _m_uploadTime, _m_startTime, _m_endTime, _current);
return ::Ice::DispatchOK;
}
private:
::Ice::Long _m_userId;
::Ice::Int _m_appType;
::Ice::Long _m_uploadTime;
const ::std::string& _m_startTime;
const ::std::string& _m_endTime;
};
::Ice::Current __current;
__initCurrent(__current, __com__xiaonei__wap__push__disturb__disturbService4Sixin__setDisturbTime_name, ::Ice::Normal, __context);
try
{
_DirectI __direct(userId, appType, uploadTime, startTime, endTime, __current);
try
{
__direct.servant()->__collocDispatch(__direct);
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
}
catch(const ::Ice::SystemException&)
{
throw;
}
catch(const ::IceInternal::LocalExceptionWrapper&)
{
throw;
}
catch(const ::std::exception& __ex)
{
::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
}
catch(...)
{
throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
}
}
void
IceDelegateD::RoboCompJoystickAdapter::JoystickAdapter::sendData(const ::RoboCompJoystickAdapter::TData& data, const ::Ice::Context* __context, ::IceInternal::InvocationObserver&)
{
class _DirectI : public ::IceInternal::Direct
{
public:
_DirectI(const ::RoboCompJoystickAdapter::TData& __p_data, const ::Ice::Current& __current) :
::IceInternal::Direct(__current),
_m_data(__p_data)
{
}
virtual ::Ice::DispatchStatus
run(::Ice::Object* object)
{
::RoboCompJoystickAdapter::JoystickAdapter* servant = dynamic_cast< ::RoboCompJoystickAdapter::JoystickAdapter*>(object);
if(!servant)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
}
servant->sendData(_m_data, _current);
return ::Ice::DispatchOK;
}
private:
const ::RoboCompJoystickAdapter::TData& _m_data;
};
::Ice::Current __current;
__initCurrent(__current, __RoboCompJoystickAdapter__JoystickAdapter__sendData_name, ::Ice::Idempotent, __context);
try
{
_DirectI __direct(data, __current);
try
{
__direct.getServant()->__collocDispatch(__direct);
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
}
catch(const ::Ice::SystemException&)
{
throw;
}
catch(const ::IceInternal::LocalExceptionWrapper&)
{
throw;
}
catch(const ::std::exception& __ex)
{
::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
}
catch(...)
{
throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
}
}
void
IceDelegateD::com::xiaonei::wap::push::token::TokenService::removeToken4Sixin(::Ice::Long userId, ::Ice::Int pushType, const ::Ice::Context* __context)
{
class _DirectI : public ::IceInternal::Direct
{
public:
_DirectI(::Ice::Long userId, ::Ice::Int pushType, const ::Ice::Current& __current) :
::IceInternal::Direct(__current),
_m_userId(userId),
_m_pushType(pushType)
{
}
virtual ::Ice::DispatchStatus
run(::Ice::Object* object)
{
::com::xiaonei::wap::push::token::TokenService* servant = dynamic_cast< ::com::xiaonei::wap::push::token::TokenService*>(object);
if(!servant)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
}
servant->removeToken4Sixin(_m_userId, _m_pushType, _current);
return ::Ice::DispatchOK;
}
private:
::Ice::Long _m_userId;
::Ice::Int _m_pushType;
};
::Ice::Current __current;
__initCurrent(__current, __com__xiaonei__wap__push__token__TokenService__removeToken4Sixin_name, ::Ice::Normal, __context);
try
{
_DirectI __direct(userId, pushType, __current);
try
{
__direct.servant()->__collocDispatch(__direct);
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
}
catch(const ::Ice::SystemException&)
{
throw;
}
catch(const ::IceInternal::LocalExceptionWrapper&)
{
throw;
}
catch(const ::std::exception& __ex)
{
::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
}
catch(...)
{
throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
}
}
void
IceDelegateD::CoreSpace::CoreBase::PrintMsg(const ::std::string& s, const ::Ice::Context* __context, ::IceInternal::InvocationObserver&)
{
class _DirectI : public ::IceInternal::Direct
{
public:
_DirectI(const ::std::string& __p_s, const ::Ice::Current& __current) :
::IceInternal::Direct(__current),
_m_s(__p_s)
{
}
virtual ::Ice::DispatchStatus
run(::Ice::Object* object)
{
::CoreSpace::CoreBase* servant = dynamic_cast< ::CoreSpace::CoreBase*>(object);
if(!servant)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
}
servant->PrintMsg(_m_s, _current);
return ::Ice::DispatchOK;
}
private:
const ::std::string& _m_s;
};
::Ice::Current __current;
__initCurrent(__current, __CoreSpace__CoreBase__PrintMsg_name, ::Ice::Normal, __context);
try
{
_DirectI __direct(s, __current);
try
{
__direct.getServant()->__collocDispatch(__direct);
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
}
catch(const ::Ice::SystemException&)
{
throw;
}
catch(const ::IceInternal::LocalExceptionWrapper&)
{
throw;
}
catch(const ::std::exception& __ex)
{
::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
}
catch(...)
{
throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
}
}
bool
IceDelegateD::RoboCompPlanning::Planning::getNextAction(const ::std::string& Problem, ::RoboCompPlanning::Plan& solution, const ::Ice::Context* __context, ::IceInternal::InvocationObserver&)
{
class _DirectI : public ::IceInternal::Direct
{
public:
_DirectI(bool& __result, const ::std::string& __p_Problem, ::RoboCompPlanning::Plan& __p_solution, const ::Ice::Current& __current) :
::IceInternal::Direct(__current),
_result(__result),
_m_Problem(__p_Problem),
_m_solution(__p_solution)
{
}
virtual ::Ice::DispatchStatus
run(::Ice::Object* object)
{
::RoboCompPlanning::Planning* servant = dynamic_cast< ::RoboCompPlanning::Planning*>(object);
if(!servant)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
}
try
{
_result = servant->getNextAction(_m_Problem, _m_solution, _current);
return ::Ice::DispatchOK;
}
catch(const ::Ice::UserException& __ex)
{
setUserException(__ex);
return ::Ice::DispatchUserException;
}
}
private:
bool& _result;
const ::std::string& _m_Problem;
::RoboCompPlanning::Plan& _m_solution;
};
::Ice::Current __current;
__initCurrent(__current, __RoboCompPlanning__Planning__getNextAction_name, ::Ice::Normal, __context);
bool __result;
try
{
_DirectI __direct(__result, Problem, solution, __current);
try
{
__direct.getServant()->__collocDispatch(__direct);
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
}
catch(const ::RoboCompPlanning::ServerException&)
{
throw;
}
catch(const ::Ice::SystemException&)
{
throw;
}
catch(const ::IceInternal::LocalExceptionWrapper&)
{
throw;
}
catch(const ::std::exception& __ex)
{
::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
}
catch(...)
{
throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
}
return __result;
}
void
IceDelegateD::Demo::Printer::printString(const ::std::string& s, bool b, ::Ice::Int i, ::Ice::Long l, ::Ice::Float f, ::Ice::Double d, const ::Ice::Context* __context, ::IceInternal::InvocationObserver&)
{
class _DirectI : public ::IceInternal::Direct
{
public:
_DirectI(const ::std::string& __p_s, bool __p_b, ::Ice::Int __p_i, ::Ice::Long __p_l, ::Ice::Float __p_f, ::Ice::Double __p_d, const ::Ice::Current& __current) :
::IceInternal::Direct(__current),
_m_s(__p_s),
_m_b(__p_b),
_m_i(__p_i),
_m_l(__p_l),
_m_f(__p_f),
_m_d(__p_d)
{
}
virtual ::Ice::DispatchStatus
run(::Ice::Object* object)
{
::Demo::Printer* servant = dynamic_cast< ::Demo::Printer*>(object);
if(!servant)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
}
servant->printString(_m_s, _m_b, _m_i, _m_l, _m_f, _m_d, _current);
return ::Ice::DispatchOK;
}
private:
const ::std::string& _m_s;
bool _m_b;
::Ice::Int _m_i;
::Ice::Long _m_l;
::Ice::Float _m_f;
::Ice::Double _m_d;
};
::Ice::Current __current;
__initCurrent(__current, __Demo__Printer__printString_name, ::Ice::Normal, __context);
try
{
_DirectI __direct(s, b, i, l, f, d, __current);
try
{
__direct.getServant()->__collocDispatch(__direct);
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
}
catch(const ::Ice::SystemException&)
{
throw;
}
catch(const ::IceInternal::LocalExceptionWrapper&)
{
throw;
}
catch(const ::std::exception& __ex)
{
::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
}
catch(...)
{
throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
}
}
::std::string
IceDelegateD::pera::Demo601Server::PeraDemo601ServerService::InvokeMethod(const ::std::string& methodName, const ::std::string& strJsonIn, const ::Ice::Context* __context, ::IceInternal::InvocationObserver&)
{
class _DirectI : public ::IceInternal::Direct
{
public:
_DirectI(::std::string& __result, const ::std::string& __p_methodName, const ::std::string& __p_strJsonIn, const ::Ice::Current& __current) :
::IceInternal::Direct(__current),
_result(__result),
_m_methodName(__p_methodName),
_m_strJsonIn(__p_strJsonIn)
{
}
virtual ::Ice::DispatchStatus
run(::Ice::Object* object)
{
::pera::Demo601Server::PeraDemo601ServerService* servant = dynamic_cast< ::pera::Demo601Server::PeraDemo601ServerService*>(object);
if(!servant)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
}
try
{
_result = servant->InvokeMethod(_m_methodName, _m_strJsonIn, _current);
return ::Ice::DispatchOK;
}
catch(const ::Ice::UserException& __ex)
{
setUserException(__ex);
return ::Ice::DispatchUserException;
}
}
private:
::std::string& _result;
const ::std::string& _m_methodName;
const ::std::string& _m_strJsonIn;
};
::Ice::Current __current;
__initCurrent(__current, __pera__Demo601Server__PeraDemo601ServerService__InvokeMethod_name, ::Ice::Normal, __context);
::std::string __result;
try
{
_DirectI __direct(__result, methodName, strJsonIn, __current);
try
{
__direct.getServant()->__collocDispatch(__direct);
}
catch(...)
{
__direct.destroy();
throw;
}
__direct.destroy();
}
catch(const ::pera::Demo601Server::InvokeException&)
{
throw;
}
catch(const ::Ice::SystemException&)
{
throw;
}
catch(const ::IceInternal::LocalExceptionWrapper&)
{
throw;
}
catch(const ::std::exception& __ex)
{
::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
}
catch(...)
{
throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
}
return __result;
}