Пример #1
0
::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);
        }
    }
}
Пример #2
0
::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;
    }
}
Пример #3
0
::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;
    }
}
Пример #4
0
::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;
    }
}
Пример #5
0
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;
    }
}
Пример #6
0
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;
    }
}
Пример #7
0
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;
    }
}
Пример #8
0
::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;
}
Пример #9
0
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);
    }
}
Пример #10
0
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);
    }
}
Пример #11
0
::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;
}
Пример #12
0
::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;
}
Пример #13
0
::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;
}
Пример #14
0
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);
    }
}
Пример #15
0
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;
}
Пример #18
0
::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;
}
Пример #19
0
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;
}
Пример #21
0
::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);
    }
}
Пример #23
0
::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;
}
Пример #24
0
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);
    }
}
Пример #25
0
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);
    }
}
Пример #26
0
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);
    }
}
Пример #27
0
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);
    }
}
Пример #28
0
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;
}
Пример #29
0
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;
}