std::vector<Parameterization> CommandManager::GetParameterizations( const std::string& serializedParams, const std::vector<SmartPointer<IParameter> >& parameters) const throw(SerializationException) { std::string serializedParameters(serializedParams); if (serializedParameters.empty() || parameters.empty()) { return std::vector<Parameterization>(); } std::vector<Parameterization> paramList; std::string::size_type commaPosition; // split off each param by looking for ',' do { commaPosition = this->UnescapedIndexOf(serializedParameters, ','); std::string idEqualsValue; if (commaPosition == std::string::npos) { // no more parameters after this idEqualsValue = serializedParameters; } else { // take the first parameter... idEqualsValue = serializedParameters.substr(0, commaPosition); // ... and put the rest back into serializedParameters serializedParameters = serializedParameters.substr(commaPosition + 1); } const std::string::size_type equalsPosition = this->UnescapedIndexOf(idEqualsValue, '='); std::string parameterId; std::string parameterValue; if (equalsPosition == std::string::npos) { // missing values are null parameterId = this->Unescape(idEqualsValue); } else { parameterId = this->Unescape(idEqualsValue.substr(0, equalsPosition)); parameterValue = this->Unescape(idEqualsValue.substr(equalsPosition + 1)); } for (unsigned int i = 0; i < parameters.size(); i++) { const IParameter::Pointer parameter(parameters[i]); if (parameter->GetId() == parameterId) { paramList.push_back(Parameterization(parameter, parameterValue)); break; } } } while (commaPosition != std::string::npos); return paramList; }
void RPC1::OnReceive(ReceivePayload *pPayload, ListenerReceiveResult *lrrOut) { OVR_UNUSED(lrrOut); if (pPayload->pData[0] == OVRID_RPC1) { OVR_ASSERT(pPayload->Bytes >= 2); OVR::Net::BitStream bsIn((char*)pPayload->pData, pPayload->Bytes, false); bsIn.IgnoreBytes(2); if (pPayload->pData[1] == RPC_ERROR_FUNCTION_NOT_REGISTERED) { Mutex::Locker locker(&callBlockingMutex); blockingReturnValue->Reset(); blockingOnThisConnection = 0; callBlockingWait.NotifyAll(); } else if (pPayload->pData[1] == ID_RPC4_RETURN) { Mutex::Locker locker(&callBlockingMutex); blockingReturnValue->Reset(); blockingReturnValue->Write(bsIn); blockingOnThisConnection = 0; callBlockingWait.NotifyAll(); } else if (pPayload->pData[1] == CALL_BLOCKING) { OVR::String uniqueId; bsIn.Read(uniqueId); RPCDelegate *bf = registeredBlockingFunctions.Get(uniqueId); if (bf==0) { OVR::Net::BitStream bsOut; bsOut.Write((unsigned char) OVRID_RPC1); bsOut.Write((unsigned char) RPC_ERROR_FUNCTION_NOT_REGISTERED); SendParameters sp(pPayload->pConnection, bsOut.GetData(), bsOut.GetNumberOfBytesUsed()); pSession->Send(&sp); return; } OVR::Net::BitStream returnData; bsIn.AlignReadToByteBoundary(); (*bf)(&bsIn, &returnData, pPayload); OVR::Net::BitStream out; out.Write((MessageID) OVRID_RPC1); out.Write((MessageID) ID_RPC4_RETURN); returnData.ResetReadPointer(); out.AlignWriteToByteBoundary(); out.Write(returnData); SendParameters sp(pPayload->pConnection, out.GetData(), out.GetNumberOfBytesUsed()); pSession->Send(&sp); } else if (pPayload->pData[1]==ID_RPC4_SIGNAL) { OVR::String sharedIdentifier; bsIn.Read(sharedIdentifier); Observer<RPCSlot> *o = slotHash.GetSubject(sharedIdentifier); if (o) { bsIn.AlignReadToByteBoundary(); if (o) { OVR::Net::BitStream serializedParameters(bsIn.GetData() + bsIn.GetReadOffset()/8, bsIn.GetNumberOfUnreadBits()/8, false); o->Call(&serializedParameters, pPayload); } } } } }