Beispiel #1
0
::Ice::DispatchStatus
com::renren::sixin::account::MiscService::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__com__renren__sixin__account__MiscService_all, __com__renren__sixin__account__MiscService_all + 10, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __com__renren__sixin__account__MiscService_all)
    {
        case 0:
        {
            return ___getAppVersion(in, current);
        }
        case 1:
        {
            return ___getLanguage(in, current);
        }
        case 2:
        {
            return ___ice_id(in, current);
        }
        case 3:
        {
            return ___ice_ids(in, current);
        }
        case 4:
        {
            return ___ice_isA(in, current);
        }
        case 5:
        {
            return ___ice_ping(in, current);
        }
        case 6:
        {
            return ___setAppId(in, current);
        }
        case 7:
        {
            return ___setLanguage(in, current);
        }
        case 8:
        {
            return ___setOriginalAppId(in, current);
        }
        case 9:
        {
            return ___syncRenrenAccount(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
Beispiel #2
0
::Ice::DispatchStatus
GlobalTable::DistributedMap::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__GlobalTable__DistributedMap_all, __GlobalTable__DistributedMap_all + 10, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __GlobalTable__DistributedMap_all)
    {
        case 0:
        {
            return ___get(in, current);
        }
        case 1:
        {
            return ___ice_id(in, current);
        }
        case 2:
        {
            return ___ice_ids(in, current);
        }
        case 3:
        {
            return ___ice_isA(in, current);
        }
        case 4:
        {
            return ___ice_ping(in, current);
        }
        case 5:
        {
            return ___put(in, current);
        }
        case 6:
        {
            return ___putNget(in, current);
        }
        case 7:
        {
            return ___remove(in, current);
        }
        case 8:
        {
            return ___set(in, current);
        }
        case 9:
        {
            return ___waitForAllClients(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
Beispiel #3
0
::IceInternal::DispatchStatus
tfs::slice::Transfer::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__tfs__slice__Transfer_all, __tfs__slice__Transfer_all + 10, current.operation);
    if(r.first == r.second)
    {
        return ::IceInternal::DispatchOperationNotExist;
    }

    switch(r.first - __tfs__slice__Transfer_all)
    {
    case 0:
    {
        return ___addChunk(in, current);
    }
    case 1:
    {
        return ___append(in, current);
    }
    case 2:
    {
        return ___getLocalPath(in, current);
    }
    case 3:
    {
        return ___ice_id(in, current);
    }
    case 4:
    {
        return ___ice_ids(in, current);
    }
    case 5:
    {
        return ___ice_isA(in, current);
    }
    case 6:
    {
        return ___ice_ping(in, current);
    }
    case 7:
    {
        return ___read(in, current);
    }
    case 8:
    {
        return ___rollback(in, current);
    }
    case 9:
    {
        return ___write(in, current);
    }
    }

    assert(false);
    return ::IceInternal::DispatchOperationNotExist;
}
Beispiel #4
0
::Ice::DispatchStatus
jderobot::Quadrotor::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__jderobot__Quadrotor_all, __jderobot__Quadrotor_all + 9, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __jderobot__Quadrotor_all)
    {
        case 0:
        {
            return ___cmdVel(in, current);
        }
        case 1:
        {
            return ___ice_id(in, current);
        }
        case 2:
        {
            return ___ice_ids(in, current);
        }
        case 3:
        {
            return ___ice_isA(in, current);
        }
        case 4:
        {
            return ___ice_ping(in, current);
        }
        case 5:
        {
            return ___land(in, current);
        }
        case 6:
        {
            return ___reset(in, current);
        }
        case 7:
        {
            return ___takeoff(in, current);
        }
        case 8:
        {
            return ___toggleCam(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
Beispiel #5
0
::Ice::DispatchStatus
com::xiaonei::wap::push::token::TokenService::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__com__xiaonei__wap__push__token__TokenService_all, __com__xiaonei__wap__push__token__TokenService_all + 8, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __com__xiaonei__wap__push__token__TokenService_all)
    {
        case 0:
        {
            return ___addToken(in, current);
        }
        case 1:
        {
            return ___addToken4Sixin(in, current);
        }
        case 2:
        {
            return ___ice_id(in, current);
        }
        case 3:
        {
            return ___ice_ids(in, current);
        }
        case 4:
        {
            return ___ice_isA(in, current);
        }
        case 5:
        {
            return ___ice_ping(in, current);
        }
        case 6:
        {
            return ___removeToken(in, current);
        }
        case 7:
        {
            return ___removeToken4Sixin(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
Beispiel #6
0
::Ice::DispatchStatus
kelp::cmd2kcn::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__kelp__cmd2kcn_all, __kelp__cmd2kcn_all + 8, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __kelp__cmd2kcn_all)
    {
        case 0:
        {
            return ___delNodeConfig(in, current);
        }
        case 1:
        {
            return ___delSelfConfig(in, current);
        }
        case 2:
        {
            return ___ice_id(in, current);
        }
        case 3:
        {
            return ___ice_ids(in, current);
        }
        case 4:
        {
            return ___ice_isA(in, current);
        }
        case 5:
        {
            return ___ice_ping(in, current);
        }
        case 6:
        {
            return ___setNodeConfig(in, current);
        }
        case 7:
        {
            return ___setSelfConfig(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
Beispiel #7
0
::Ice::DispatchStatus
Temp::TimeInfo::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__Temp__TimeInfo_all, __Temp__TimeInfo_all + 8, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __Temp__TimeInfo_all)
    {
        case 0:
        {
            return ___getServerInfo(in, current);
        }
        case 1:
        {
            return ___getServerInfos(in, current);
        }
        case 2:
        {
            return ___getServerTime(in, current);
        }
        case 3:
        {
            return ___getTimeInfo(in, current);
        }
        case 4:
        {
            return ___ice_id(in, current);
        }
        case 5:
        {
            return ___ice_ids(in, current);
        }
        case 6:
        {
            return ___ice_isA(in, current);
        }
        case 7:
        {
            return ___ice_ping(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
Beispiel #8
0
::IceInternal::DispatchStatus
orca::util::LatencyReplier::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__orca__util__LatencyReplier_all, __orca__util__LatencyReplier_all + 8, current.operation);
    if(r.first == r.second)
    {
        return ::IceInternal::DispatchOperationNotExist;
    }

    switch(r.first - __orca__util__LatencyReplier_all)
    {
        case 0:
        {
            return ___ice_id(in, current);
        }
        case 1:
        {
            return ___ice_ids(in, current);
        }
        case 2:
        {
            return ___ice_isA(in, current);
        }
        case 3:
        {
            return ___ice_ping(in, current);
        }
        case 4:
        {
            return ___setPinger(in, current);
        }
        case 5:
        {
            return ___shutdown(in, current);
        }
        case 6:
        {
            return ___takeIt(in, current);
        }
        case 7:
        {
            return ___takeItAndReturn(in, current);
        }
    }

    assert(false);
    return ::IceInternal::DispatchOperationNotExist;
}
Beispiel #9
0
::Ice::DispatchStatus
OWSMODULE::DataOperation::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__OWSMODULE__DataOperation_all, __OWSMODULE__DataOperation_all + 7, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __OWSMODULE__DataOperation_all)
    {
        case 0:
        {
            return ___CheckState(in, current);
        }
        case 1:
        {
            return ___ReadData(in, current);
        }
        case 2:
        {
            return ___ice_id(in, current);
        }
        case 3:
        {
            return ___ice_ids(in, current);
        }
        case 4:
        {
            return ___ice_isA(in, current);
        }
        case 5:
        {
            return ___ice_ping(in, current);
        }
        case 6:
        {
            return ___shutdown(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
::Ice::DispatchStatus
com::pera::base::runtime::remote::RobotRemoteService::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__com__pera__base__runtime__remote__RobotRemoteService_all, __com__pera__base__runtime__remote__RobotRemoteService_all + 7, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __com__pera__base__runtime__remote__RobotRemoteService_all)
    {
        case 0:
        {
            return ___ice_id(in, current);
        }
        case 1:
        {
            return ___ice_ids(in, current);
        }
        case 2:
        {
            return ___ice_isA(in, current);
        }
        case 3:
        {
            return ___ice_ping(in, current);
        }
        case 4:
        {
            return ___runLocalRobotStart(in, current);
        }
        case 5:
        {
            return ___runRobotStart(in, current);
        }
        case 6:
        {
            return ___runRobotStop(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
Beispiel #11
0
::Ice::DispatchStatus
CoreSpace::CoreBase::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__CoreSpace__CoreBase_all, __CoreSpace__CoreBase_all + 7, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __CoreSpace__CoreBase_all)
    {
        case 0:
        {
            return ___PrintMsg(in, current);
        }
        case 1:
        {
            return ___add(in, current);
        }
        case 2:
        {
            return ___ice_id(in, current);
        }
        case 3:
        {
            return ___ice_ids(in, current);
        }
        case 4:
        {
            return ___ice_isA(in, current);
        }
        case 5:
        {
            return ___ice_ping(in, current);
        }
        case 6:
        {
            return ___sub(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
Beispiel #12
0
::Ice::DispatchStatus
MCS::MESLink::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__MCS__MESLink_all, __MCS__MESLink_all + 7, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __MCS__MESLink_all)
    {
        case 0:
        {
            return ___GetFoup(in, current);
        }
        case 1:
        {
            return ___PickFoup(in, current);
        }
        case 2:
        {
            return ___PlaceFoup(in, current);
        }
        case 3:
        {
            return ___ice_id(in, current);
        }
        case 4:
        {
            return ___ice_ids(in, current);
        }
        case 5:
        {
            return ___ice_isA(in, current);
        }
        case 6:
        {
            return ___ice_ping(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
::Ice::DispatchStatus
RoboCompAriaMapInformation::AriaMapInformation::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__RoboCompAriaMapInformation__AriaMapInformation_all, __RoboCompAriaMapInformation__AriaMapInformation_all + 7, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __RoboCompAriaMapInformation__AriaMapInformation_all)
    {
        case 0:
        {
            return ___goalInformation(in, current);
        }
        case 1:
        {
            return ___ice_id(in, current);
        }
        case 2:
        {
            return ___ice_ids(in, current);
        }
        case 3:
        {
            return ___ice_isA(in, current);
        }
        case 4:
        {
            return ___ice_ping(in, current);
        }
        case 5:
        {
            return ___mapInformation(in, current);
        }
        case 6:
        {
            return ___robotInformation(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
Beispiel #14
0
::IceInternal::DispatchStatus
BHAco::Request::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__BHAco__Request_all, __BHAco__Request_all + 7, current.operation);
    if(r.first == r.second)
    {
        return ::IceInternal::DispatchOperationNotExist;
    }

    switch(r.first - __BHAco__Request_all)
    {
        case 0:
        {
            return ___RequestData(in, current);
        }
        case 1:
        {
            return ___ice_id(in, current);
        }
        case 2:
        {
            return ___ice_ids(in, current);
        }
        case 3:
        {
            return ___ice_isA(in, current);
        }
        case 4:
        {
            return ___ice_ping(in, current);
        }
        case 5:
        {
            return ___sayHello(in, current);
        }
        case 6:
        {
            return ___shutdown(in, current);
        }
    }

    assert(false);
    return ::IceInternal::DispatchOperationNotExist;
}
::Ice::DispatchStatus
UC3M::CineTicketService::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__UC3M__CineTicketService_all, __UC3M__CineTicketService_all + 7, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __UC3M__CineTicketService_all)
    {
        case 0:
        {
            return ___cancela(in, current);
        }
        case 1:
        {
            return ___consulta(in, current);
        }
        case 2:
        {
            return ___ice_id(in, current);
        }
        case 3:
        {
            return ___ice_ids(in, current);
        }
        case 4:
        {
            return ___ice_isA(in, current);
        }
        case 5:
        {
            return ___ice_ping(in, current);
        }
        case 6:
        {
            return ___reserva(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
Beispiel #16
0
::Ice::DispatchStatus
loggerice::loggerctrl::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__loggerice__loggerctrl_all, __loggerice__loggerctrl_all + 7, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __loggerice__loggerctrl_all)
    {
    case 0:
    {
        return ___Register(in, current);
    }
    case 1:
    {
        return ___SetName(in, current);
    }
    case 2:
    {
        return ___SetThreadName(in, current);
    }
    case 3:
    {
        return ___ice_id(in, current);
    }
    case 4:
    {
        return ___ice_ids(in, current);
    }
    case 5:
    {
        return ___ice_isA(in, current);
    }
    case 6:
    {
        return ___ice_ping(in, current);
    }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
Beispiel #17
0
::Ice::DispatchStatus
Client::CClient::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__Client__CClient_all, __Client__CClient_all + 7, current.operation);
    if(r.first == r.second)
    {
        throw Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __Client__CClient_all)
    {
        case 0:
        {
            return ___cam(in, current);
        }
        case 1:
        {
            return ___chat(in, current);
        }
        case 2:
        {
            return ___ice_id(in, current);
        }
        case 3:
        {
            return ___ice_ids(in, current);
        }
        case 4:
        {
            return ___ice_isA(in, current);
        }
        case 5:
        {
            return ___ice_ping(in, current);
        }
        case 6:
        {
            return ___moto(in, current);
        }
    }

    assert(false);
    throw Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
Beispiel #18
0
::Ice::DispatchStatus
RoboCompGenericBase::GenericBase::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__RoboCompGenericBase__GenericBase_all, __RoboCompGenericBase__GenericBase_all + 6, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __RoboCompGenericBase__GenericBase_all)
    {
        case 0:
        {
            return ___getBasePose(in, current);
        }
        case 1:
        {
            return ___getBaseState(in, current);
        }
        case 2:
        {
            return ___ice_id(in, current);
        }
        case 3:
        {
            return ___ice_ids(in, current);
        }
        case 4:
        {
            return ___ice_isA(in, current);
        }
        case 5:
        {
            return ___ice_ping(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
::Ice::DispatchStatus
RoboCompJoyStick::JoyStick::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__RoboCompJoyStick__JoyStick_all, __RoboCompJoyStick__JoyStick_all + 6, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __RoboCompJoyStick__JoyStick_all)
    {
    case 0:
    {
        return ___ice_id(in, current);
    }
    case 1:
    {
        return ___ice_ids(in, current);
    }
    case 2:
    {
        return ___ice_isA(in, current);
    }
    case 3:
    {
        return ___ice_ping(in, current);
    }
    case 4:
    {
        return ___readJoyStickBufferedData(in, current);
    }
    case 5:
    {
        return ___writeJoyStickBufferedData(in, current);
    }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
::Ice::DispatchStatus
Demo::Printer::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__Demo__Printer_all, __Demo__Printer_all + 6, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __Demo__Printer_all)
    {
        case 0:
        {
            return ___ice_id(in, current);
        }
        case 1:
        {
            return ___ice_ids(in, current);
        }
        case 2:
        {
            return ___ice_isA(in, current);
        }
        case 3:
        {
            return ___ice_ping(in, current);
        }
        case 4:
        {
            return ___printString(in, current);
        }
        case 5:
        {
            return ___shutdown(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
::Ice::DispatchStatus
Communication::DataInterface::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__Communication__DataInterface_all, __Communication__DataInterface_all + 6, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __Communication__DataInterface_all)
    {
        case 0:
        {
            return ___ice_id(in, current);
        }
        case 1:
        {
            return ___ice_ids(in, current);
        }
        case 2:
        {
            return ___ice_isA(in, current);
        }
        case 3:
        {
            return ___ice_ping(in, current);
        }
        case 4:
        {
            return ___sendByteData(in, current);
        }
        case 5:
        {
            return ___sendFloatData(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
Beispiel #22
0
::Ice::DispatchStatus zerocexample::MessageIce::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
	::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(__zerocexample__MessageIce_all, __zerocexample__MessageIce_all + 6, current.operation);
	if (r.first == r.second)
	{
		throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
	}

	switch (r.first - __zerocexample__MessageIce_all)
	{
		case 0:
			{
				return ___getContent(in, current);
			}
		case 1:
			{
				return ___ice_id(in, current);
			}
		case 2:
			{
				return ___ice_ids(in, current);
			}
		case 3:
			{
				return ___ice_isA(in, current);
			}
		case 4:
			{
				return ___ice_ping(in, current);
			}
		case 5:
			{
				return ___setContent(in, current);
			}
	}

	assert(false);
	throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
::Ice::DispatchStatus
RoboCompSpeechUnderstanding::SpeechUnderstanding::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__RoboCompSpeechUnderstanding__SpeechUnderstanding_all, __RoboCompSpeechUnderstanding__SpeechUnderstanding_all + 5, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __RoboCompSpeechUnderstanding__SpeechUnderstanding_all)
    {
        case 0:
        {
            return ___CFR(in, current);
        }
        case 1:
        {
            return ___ice_id(in, current);
        }
        case 2:
        {
            return ___ice_ids(in, current);
        }
        case 3:
        {
            return ___ice_isA(in, current);
        }
        case 4:
        {
            return ___ice_ping(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
::Ice::DispatchStatus
Pera::PcIdToWsServer::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__Pera__PcIdToWsServer_all, __Pera__PcIdToWsServer_all + 5, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __Pera__PcIdToWsServer_all)
    {
    case 0:
    {
        return ___TellClientId(in, current);
    }
    case 1:
    {
        return ___ice_id(in, current);
    }
    case 2:
    {
        return ___ice_ids(in, current);
    }
    case 3:
    {
        return ___ice_isA(in, current);
    }
    case 4:
    {
        return ___ice_ping(in, current);
    }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
Beispiel #25
0
::IceInternal::DispatchStatus
ICSSW::Notifier::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__ICSSW__Notifier_all, __ICSSW__Notifier_all + 5, current.operation);
    if(r.first == r.second)
    {
        return ::IceInternal::DispatchOperationNotExist;
    }

    switch(r.first - __ICSSW__Notifier_all)
    {
        case 0:
        {
            return ___ice_id(in, current);
        }
        case 1:
        {
            return ___ice_ids(in, current);
        }
        case 2:
        {
            return ___ice_isA(in, current);
        }
        case 3:
        {
            return ___ice_ping(in, current);
        }
        case 4:
        {
            return ___notify(in, current);
        }
    }

    assert(false);
    return ::IceInternal::DispatchOperationNotExist;
}
Beispiel #26
0
::Ice::DispatchStatus
Pri::AcDisp::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& c)
{
    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__Pri__Ac_ops, __Pri__Ac_ops + 5, c.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, c.id, c.facet, c.operation);
    }

    switch(r.first - __Pri__Ac_ops)
    {
        case 0:
        {
            return ___get(in, c);
        }
        case 1:
        {
            return ___ice_id(in, c);
        }
        case 2:
        {
            return ___ice_ids(in, c);
        }
        case 3:
        {
            return ___ice_isA(in, c);
        }
        case 4:
        {
            return ___ice_ping(in, c);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, c.id, c.facet, c.operation);
}
Beispiel #27
0
::Ice::DispatchStatus
level1::level2::test::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__level1__level2__test_all, __level1__level2__test_all + 5, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __level1__level2__test_all)
    {
        case 0:
        {
            return ___ice_id(in, current);
        }
        case 1:
        {
            return ___ice_ids(in, current);
        }
        case 2:
        {
            return ___ice_isA(in, current);
        }
        case 3:
        {
            return ___ice_ping(in, current);
        }
        case 4:
        {
            return ___output(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
::Ice::DispatchStatus
RoboCompCommonBehavior::CommonBehavior::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__RoboCompCommonBehavior__CommonBehavior_all, __RoboCompCommonBehavior__CommonBehavior_all + 12, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __RoboCompCommonBehavior__CommonBehavior_all)
    {
        case 0:
        {
            return ___getParameterList(in, current);
        }
        case 1:
        {
            return ___getPeriod(in, current);
        }
        case 2:
        {
            return ___getState(in, current);
        }
        case 3:
        {
            return ___ice_id(in, current);
        }
        case 4:
        {
            return ___ice_ids(in, current);
        }
        case 5:
        {
            return ___ice_isA(in, current);
        }
        case 6:
        {
            return ___ice_ping(in, current);
        }
        case 7:
        {
            return ___killYourSelf(in, current);
        }
        case 8:
        {
            return ___reloadConfig(in, current);
        }
        case 9:
        {
            return ___setParameterList(in, current);
        }
        case 10:
        {
            return ___setPeriod(in, current);
        }
        case 11:
        {
            return ___timeAwake(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}