upgrade to yarp-3.5.1

pattacini · Nicogene · commit 3fb83bc222cd · 2021-12-03T14:02:44.000+01:00
diff --git a/iSpeak/main.cpp b/iSpeak/main.cpp
@@ -109,9 +109,9 @@ class MouthHandler : public PeriodicThread
         if (emotions.getOutputCount()>0)
         {
             Bottle cmd, reply;
-            cmd.addVocab(Vocab::encode("set"));
-            cmd.addVocab(Vocab::encode("mou"));
-            cmd.addVocab(Vocab::encode(state));
+            cmd.addVocab32("set");
+            cmd.addVocab32("mou");
+            cmd.addVocab32(state);
             emotions.write(cmd,reply);
         }
     }
@@ -141,7 +141,7 @@ class MouthHandler : public PeriodicThread
         if (r1.getOutputCount()>0)
         {
             Bottle cmd,rep;
-            cmd.addVocab(Vocab::encode("tstart"));
+            cmd.addVocab32("tstart");
             r1.write(cmd,rep);
         }
 
@@ -170,7 +170,7 @@ class MouthHandler : public PeriodicThread
         r1.open("/"+name+"/r1:rpc");
 
         state="sur";
-        setPeriod((double)rf.check("period",Value(200)).asInt()/1000.0);
+        setPeriod((double)rf.check("period",Value(200)).asInt32()/1000.0);
     }
 
     /************************************************************************/
@@ -185,7 +185,7 @@ class MouthHandler : public PeriodicThread
         if (r1.getOutputCount()>0)
         {
             Bottle cmd,rep;
-            cmd.addVocab(Vocab::encode("tstart"));
+            cmd.addVocab32("tstart");
             r1.write(cmd,rep);
         }
 
@@ -208,7 +208,7 @@ class MouthHandler : public PeriodicThread
         if (r1.getOutputCount()>0)
         {
             Bottle cmd,rep;
-            cmd.addVocab(Vocab::encode("tstop"));
+            cmd.addVocab32("tstop");
             r1.write(cmd,rep);
         }
     }
@@ -335,17 +335,17 @@ class iSpeak : protected BufferedPort<Bottle>,
             {
                 if (request.get(0).isString())
                     phrase=request.get(0).asString();
-                else if (request.get(0).isDouble() || request.get(0).isInt())
+                else if (request.get(0).isFloat64() || request.get(0).isInt32())
                 {
-                    time=request.get(0).asDouble();
+                    time=request.get(0).asFloat64();
                     onlyMouth=true;
                 }
 
                 if (request.size()>1)
                 {
-                    if (request.get(1).isInt())
+                    if (request.get(1).isInt32())
                     {
-                        int newRate=request.get(1).asInt();
+                        int newRate=request.get(1).asInt32();
                         if (newRate>0)
                         {
                             mouth.setPeriod((double)newRate/1000.0);
@@ -354,8 +354,8 @@ class iSpeak : protected BufferedPort<Bottle>,
                     }
 
                     if ((request.size()>2) && request.get(0).isString())
-                        if (request.get(2).isDouble() || request.get(2).isInt())
-                            duration=request.get(2).asDouble();
+                        if (request.get(2).isFloat64() || request.get(2).isInt32())
+                            duration=request.get(2).asFloat64();
                 }
             }
         }
@@ -474,19 +474,19 @@ class Launcher: public RFModule
     /************************************************************************/
     bool respond(const Bottle &command, Bottle &reply)
     {
-        int cmd0=command.get(0).asVocab();
-        if (cmd0==Vocab::encode("stat"))
+        int cmd0=command.get(0).asVocab32();
+        if (cmd0==Vocab32::encode("stat"))
         {
             reply.addString(speaker.isSpeaking()?"speaking":"quiet");
             return true;
         }
 
         if (command.size()>1)
         {
-            int cmd1=command.get(1).asVocab();
-            if (cmd1==Vocab::encode("opt"))
+            int cmd1=command.get(1).asVocab32();
+            if (cmd1==Vocab32::encode("opt"))
             {
-                if (cmd0==Vocab::encode("set"))
+                if (cmd0==Vocab32::encode("set"))
                 {
                     if (command.size()>2)
                     {
@@ -496,7 +496,7 @@ class Launcher: public RFModule
                         return true;
                     }
                 }
-                else if (cmd0==Vocab::encode("get"))
+                else if (cmd0==Vocab32::encode("get"))
                 {
                     reply.addString(speaker.get_package_options());
                     return true;
diff --git a/speech-interpreters/start/input/src/start-speech.cpp b/speech-interpreters/start/input/src/start-speech.cpp
@@ -238,7 +238,7 @@ void STARTManager::onRead(yarp::os::Bottle &bot)
                         {
                             std::string::size_type sz;   // alias of size_t
                             int i_dec = std::stoi (words,&sz);
-                            finalTmp.addInt(i_dec);
+                            finalTmp.addInt32(i_dec);
                         }
                     }
                     answer.erase(answer.find_first_of("["), answer.find_first_of("]"));
diff --git a/speechInteraction/CMakeLists.txt b/speechInteraction/CMakeLists.txt
@@ -20,7 +20,7 @@ find_package(ICUBcontrib REQUIRED)
 find_package(Protobuf REQUIRED)
 find_package(gRPC CONFIG REQUIRED)
 find_package(GOOGLEAPIS REQUIRED)
-find_package(YARP 3.2.1 REQUIRED COMPONENTS OS sig dev math)
+find_package(YARP 3.5.1 REQUIRED COMPONENTS OS sig dev math)
 
 include_directories(${googleapis_INCLUDE_DIR})
 
diff --git a/speechInteraction/modules/googleSpeech/main.cpp b/speechInteraction/modules/googleSpeech/main.cpp
@@ -332,7 +332,7 @@ class Processing : public yarp::os::TypedReaderCallback<yarp::sig::Sound>
     {           
         std::lock_guard<std::mutex> lg(mtx); 
         yarp::os::Bottle cmd, rep;
-        //cmd.addVocab(yarp::os::Vocab::encode("start"));
+        //cmd.addVocab32("start");
         cmd.addString("start");
         if (audioCommand.write(cmd, rep))
         {
@@ -405,7 +405,7 @@ class Module : public yarp::os::RFModule, public googleSpeech_IDL
 
         std::string moduleName = rf.check("name", yarp::os::Value("googleSpeech"), "module name (string)").asString();
         std::string language = rf.check("language_code", yarp::os::Value("en-US"), "language (string)").asString();
-        int sample_rate = rf.check("sample_rate_hertz", yarp::os::Value(16000), "sample rate (int)").asInt();
+        int sample_rate = rf.check("sample_rate_hertz", yarp::os::Value(16000), "sample rate (int)").asInt32();
         
         if (rf.check("uniqueSound", "use a yarp::sig::Sound instead of a microphone"))
             uniqueSound = true;
diff --git a/speechInteraction/modules/googleSpeechProcess/main.cpp b/speechInteraction/modules/googleSpeechProcess/main.cpp
@@ -382,11 +382,11 @@ class Processing : public yarp::os::BufferedPort<yarp::os::Bottle>
         yarp::os::Bottle &sentiment_score = sentiment.addList();   
         sentiment_score.addString("Score");
         std::pair<float,float> sentiment_result = read_sentiment( sentiment_sentences );
-        sentiment_score.addDouble(sentiment_result.second);
+        sentiment_score.addFloat64(sentiment_result.second);
 
         yarp::os::Bottle &sentiment_magnitude = sentiment.addList();   
         sentiment_magnitude.addString("Magnitude");
-        sentiment_magnitude.addDouble(sentiment_result.first);
+        sentiment_magnitude.addFloat64(sentiment_result.first);
 
         yInfo() << "wordList " << wordList.toString().c_str();
        
@@ -618,15 +618,15 @@ class Processing : public yarp::os::BufferedPort<yarp::os::Bottle>
         sentiment_analysis.addString(sentence); //add the sentence
         yarp::os::Bottle* sentiment = wordList.get(0).asList()->get(element-1).asList(); 
         //yInfo() << "sentiment " << sentiment->toString();//Sentiment (Score 0.100000001490116119385) (Magnitude 0.100000001490116119385) 
-        double score = sentiment->get(1).asList()->get(1).asDouble();
-        double magnitude = sentiment->get(2).asList()->get(1).asDouble();
+        double score = sentiment->get(1).asList()->get(1).asFloat64();
+        double magnitude = sentiment->get(2).asList()->get(1).asFloat64();
         //printf("Values: %f %f\n", score, magnitude);
         yarp::os::Bottle &each_score = sentiment_analysis.addList();
         each_score.addString("Score"); //add the corresponding score
-        each_score.addDouble(score);
+        each_score.addFloat64(score);
         yarp::os::Bottle &each_magnitude = sentiment_analysis.addList();
         each_magnitude.addString("Magnitude"); //add the corresponding magnitude
-        each_magnitude.addDouble(magnitude);
+        each_magnitude.addFloat64(magnitude);
         
 
 
diff --git a/speechInteraction/modules/googleSynthesis/main.cpp b/speechInteraction/modules/googleSynthesis/main.cpp
@@ -316,8 +316,8 @@ class Module : public yarp::os::RFModule, public googleSynthesis_IDL
         std::string language = rf.check("language", yarp::os::Value("en-US"), "language to use (string)").asString();
         std::string voice = rf.check("voice", yarp::os::Value("en-US-Wavenet-D"), "voice to use (string)").asString();
 
-        double speed = rf.check("speed", yarp::os::Value(1.0), "speed to use (double)").asDouble();
-        double pitch = rf.check("pitch", yarp::os::Value(0.0), "pitch to use (double)").asDouble();
+        double speed = rf.check("speed", yarp::os::Value(1.0), "speed to use (double)").asFloat64();
+        double pitch = rf.check("pitch", yarp::os::Value(0.0), "pitch to use (double)").asFloat64();
 
         if (rf.check("languageCodes", "Getting language codes"))
         {
diff --git a/speechRecognizer/src/SpeechRecognizerModule.cpp b/speechRecognizer/src/SpeechRecognizerModule.cpp
@@ -53,7 +53,7 @@ std::vector<std::string> split(const std::string &s, char delim) {
 bool SpeechRecognizerModule::configure(ResourceFinder &rf )
 {
     setName( rf.check("name",Value("speechRecognizer")).asString().c_str() );
-    m_timeout = rf.check("timeout",Value(10000)).asInt();
+    m_timeout = rf.check("timeout",Value(10000)).asInt32();
     USE_LEGACY = !rf.check("noLegacy");
     m_forwardSound = rf.check("forwardSound");
     m_tmpFileFolder = rf.getHomeContextPath();
@@ -265,7 +265,7 @@ bool SpeechRecognizerModule::updateModule()
                         //Send over yarp
                         Bottle bOut;
                         bOut.addString(fullSentence);
-                        bOut.addInt(confidence);
+                        bOut.addInt32(confidence);
                         m_portContinuousRecognition.write(bOut);
 
                         //Treat the semantic
@@ -644,7 +644,7 @@ string SpeechRecognizerModule::getFromDictaction(int timeout, LPCWSTR options )
         for(list< pair<string, double> >::iterator it = results.begin(); it != results.end(); it++)
         {
             botTmp.addString(it->first);
-            //botTmp.addDouble(it->second);
+            //botTmp.addFloat64(it->second);
         }
     }
     yInfo() <<"Dictation is off...";
@@ -662,8 +662,8 @@ bool SpeechRecognizerModule::handleRecognitionCmd(const Bottle& cmd, Bottle& rep
 
     if (firstVocab == "timeout")
     {
-        m_timeout = cmd.get(1).asInt();
-        //reply.addInt(true);
+        m_timeout = cmd.get(1).asInt32();
+        //reply.addInt32(true);
         return false;
     }
 
@@ -684,7 +684,7 @@ bool SpeechRecognizerModule::handleRecognitionCmd(const Bottle& cmd, Bottle& rep
                 for(list< pair<string, double> >::iterator it = results.begin(); it != results.end(); it++)
                 {
                     reply.addString(it->first);
-                    reply.addDouble(it->second);
+                    reply.addFloat64(it->second);
                 }
             else
                 reply.addString("-1");
@@ -694,7 +694,7 @@ bool SpeechRecognizerModule::handleRecognitionCmd(const Bottle& cmd, Bottle& rep
         //Turn off dictation and go back to the file grammar
         everythingIsFine &= SUCCEEDED(m_cpGrammarDictation->SetDictationState( SPRS_INACTIVE ));
         everythingIsFine &=SUCCEEDED(m_cpGrammarFromFile->SetGrammarState(SPGS_ENABLED));  
-        //reply.addInt(true);
+        //reply.addInt32(true);
         return true;
     }    
     // If we are not in dictation then we set and switch to the runtimeGrammar
@@ -716,7 +716,7 @@ bool SpeechRecognizerModule::handleRecognitionCmd(const Bottle& cmd, Bottle& rep
 
         refreshFromVocabulories(m_cpGrammarRuntime);
 
-        //reply.addInt(everythingIsFine);
+        //reply.addInt32(everythingIsFine);
     }
 
     else if (firstVocab == "choices")
@@ -758,7 +758,7 @@ bool SpeechRecognizerModule::handleRecognitionCmd(const Bottle& cmd, Bottle& rep
             for(list< pair<string, double> >::iterator it = results.begin(); it != results.end(); it++)
             {
                 reply.addString(it->first);
-                reply.addDouble(it->second);
+                reply.addFloat64(it->second);
             }
         else
             reply.addString("-1");
@@ -882,7 +882,7 @@ void SpeechRecognizerModule::say(string s, bool wait)
     if(wait)
     {
         yarp::os::Bottle cmd,reply;
-        cmd.addVocab(VOCAB('s','t','a','t'));
+        cmd.addVocab32(VOCAB('s','t','a','t'));
         std::string status = "speaking";
         bool speechStarted = false;
         while(wait&&(!speechStarted ||status=="speaking"))
diff --git a/svox-speech/speech.cpp b/svox-speech/speech.cpp
@@ -82,8 +82,8 @@ bool Speech::open(yarp::os::Searchable &config)
             return false;
         }
 
-    setPitch(config.check("pitch",Value(90)).asInt());
-    setSpeed(config.check("speed",Value(105)).asInt());
+    setPitch(config.check("pitch",Value(90)).asInt32());
+    setSpeed(config.check("speed",Value(105)).asInt32());
 
     lingwareRF.setDefaultContext(config.check("lingware-context",Value("speech")).asString());
     lingwareRF.configure(0,NULL);

Original file line number	Diff line number	Diff line change
`@@ -109,9 +109,9 @@ class MouthHandler : public PeriodicThread`
`109`	`109`	`if (emotions.getOutputCount()>0)`
`110`	`110`	`{`
`111`	`111`	`Bottle cmd, reply;`
`112`		`- cmd.addVocab(Vocab::encode("set"));`
`113`		`- cmd.addVocab(Vocab::encode("mou"));`
`114`		`- cmd.addVocab(Vocab::encode(state));`
	`112`	`+ cmd.addVocab32("set");`
	`113`	`+ cmd.addVocab32("mou");`
	`114`	`+ cmd.addVocab32(state);`
`115`	`115`	`emotions.write(cmd,reply);`
`116`	`116`	`}`
`117`	`117`	`}`
`@@ -141,7 +141,7 @@ class MouthHandler : public PeriodicThread`
`141`	`141`	`if (r1.getOutputCount()>0)`
`142`	`142`	`{`
`143`	`143`	`Bottle cmd,rep;`
`144`		`- cmd.addVocab(Vocab::encode("tstart"));`
	`144`	`+ cmd.addVocab32("tstart");`
`145`	`145`	`r1.write(cmd,rep);`
`146`	`146`	`}`
`147`	`147`
`@@ -170,7 +170,7 @@ class MouthHandler : public PeriodicThread`
`170`	`170`	`r1.open("/"+name+"/r1:rpc");`
`171`	`171`
`172`	`172`	`state="sur";`
`173`		`- setPeriod((double)rf.check("period",Value(200)).asInt()/1000.0);`
	`173`	`+ setPeriod((double)rf.check("period",Value(200)).asInt32()/1000.0);`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`/************************************************************************/`
`@@ -185,7 +185,7 @@ class MouthHandler : public PeriodicThread`
`185`	`185`	`if (r1.getOutputCount()>0)`
`186`	`186`	`{`
`187`	`187`	`Bottle cmd,rep;`
`188`		`- cmd.addVocab(Vocab::encode("tstart"));`
	`188`	`+ cmd.addVocab32("tstart");`
`189`	`189`	`r1.write(cmd,rep);`
`190`	`190`	`}`
`191`	`191`
`@@ -208,7 +208,7 @@ class MouthHandler : public PeriodicThread`
`208`	`208`	`if (r1.getOutputCount()>0)`
`209`	`209`	`{`
`210`	`210`	`Bottle cmd,rep;`
`211`		`- cmd.addVocab(Vocab::encode("tstop"));`
	`211`	`+ cmd.addVocab32("tstop");`
`212`	`212`	`r1.write(cmd,rep);`
`213`	`213`	`}`
`214`	`214`	`}`
`@@ -335,17 +335,17 @@ class iSpeak : protected BufferedPort<Bottle>,`
`335`	`335`	`{`
`336`	`336`	`if (request.get(0).isString())`
`337`	`337`	`phrase=request.get(0).asString();`
`338`		`- else if (request.get(0).isDouble() \|\| request.get(0).isInt())`
	`338`	`+ else if (request.get(0).isFloat64() \|\| request.get(0).isInt32())`
`339`	`339`	`{`
`340`		`- time=request.get(0).asDouble();`
	`340`	`+ time=request.get(0).asFloat64();`
`341`	`341`	`onlyMouth=true;`
`342`	`342`	`}`
`343`	`343`
`344`	`344`	`if (request.size()>1)`
`345`	`345`	`{`
`346`		`- if (request.get(1).isInt())`
	`346`	`+ if (request.get(1).isInt32())`
`347`	`347`	`{`
`348`		`- int newRate=request.get(1).asInt();`
	`348`	`+ int newRate=request.get(1).asInt32();`
`349`	`349`	`if (newRate>0)`
`350`	`350`	`{`
`351`	`351`	`mouth.setPeriod((double)newRate/1000.0);`
`@@ -354,8 +354,8 @@ class iSpeak : protected BufferedPort<Bottle>,`
`354`	`354`	`}`
`355`	`355`
`356`	`356`	`if ((request.size()>2) && request.get(0).isString())`
`357`		`- if (request.get(2).isDouble() \|\| request.get(2).isInt())`
`358`		`- duration=request.get(2).asDouble();`
	`357`	`+ if (request.get(2).isFloat64() \|\| request.get(2).isInt32())`
	`358`	`+ duration=request.get(2).asFloat64();`
`359`	`359`	`}`
`360`	`360`	`}`
`361`	`361`	`}`
`@@ -474,19 +474,19 @@ class Launcher: public RFModule`
`474`	`474`	`/************************************************************************/`
`475`	`475`	`bool respond(const Bottle &command, Bottle &reply)`
`476`	`476`	`{`
`477`		`- int cmd0=command.get(0).asVocab();`
`478`		`- if (cmd0==Vocab::encode("stat"))`
	`477`	`+ int cmd0=command.get(0).asVocab32();`
	`478`	`+ if (cmd0==Vocab32::encode("stat"))`
`479`	`479`	`{`
`480`	`480`	`reply.addString(speaker.isSpeaking()?"speaking":"quiet");`
`481`	`481`	`return true;`
`482`	`482`	`}`
`483`	`483`
`484`	`484`	`if (command.size()>1)`
`485`	`485`	`{`
`486`		`- int cmd1=command.get(1).asVocab();`
`487`		`- if (cmd1==Vocab::encode("opt"))`
	`486`	`+ int cmd1=command.get(1).asVocab32();`
	`487`	`+ if (cmd1==Vocab32::encode("opt"))`
`488`	`488`	`{`
`489`		`- if (cmd0==Vocab::encode("set"))`
	`489`	`+ if (cmd0==Vocab32::encode("set"))`
`490`	`490`	`{`
`491`	`491`	`if (command.size()>2)`
`492`	`492`	`{`
`@@ -496,7 +496,7 @@ class Launcher: public RFModule`
`496`	`496`	`return true;`
`497`	`497`	`}`
`498`	`498`	`}`
`499`		`- else if (cmd0==Vocab::encode("get"))`
	`499`	`+ else if (cmd0==Vocab32::encode("get"))`
`500`	`500`	`{`
`501`	`501`	`reply.addString(speaker.get_package_options());`
`502`	`502`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -238,7 +238,7 @@ void STARTManager::onRead(yarp::os::Bottle &bot)`
`238`	`238`	`{`
`239`	`239`	`std::string::size_type sz; // alias of size_t`
`240`	`240`	`int i_dec = std::stoi (words,&sz);`
`241`		`- finalTmp.addInt(i_dec);`
	`241`	`+ finalTmp.addInt32(i_dec);`
`242`	`242`	`}`
`243`	`243`	`}`
`244`	`244`	`answer.erase(answer.find_first_of("["), answer.find_first_of("]"));`
Original file line number	Diff line number	Diff line change
`@@ -316,8 +316,8 @@ class Module : public yarp::os::RFModule, public googleSynthesis_IDL`
`316`	`316`	`std::string language = rf.check("language", yarp::os::Value("en-US"), "language to use (string)").asString();`
`317`	`317`	`std::string voice = rf.check("voice", yarp::os::Value("en-US-Wavenet-D"), "voice to use (string)").asString();`
`318`	`318`
`319`		`- double speed = rf.check("speed", yarp::os::Value(1.0), "speed to use (double)").asDouble();`
`320`		`- double pitch = rf.check("pitch", yarp::os::Value(0.0), "pitch to use (double)").asDouble();`
	`319`	`+ double speed = rf.check("speed", yarp::os::Value(1.0), "speed to use (double)").asFloat64();`
	`320`	`+ double pitch = rf.check("pitch", yarp::os::Value(0.0), "pitch to use (double)").asFloat64();`
`321`	`321`
`322`	`322`	`if (rf.check("languageCodes", "Getting language codes"))`
`323`	`323`	`{`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ std::vector<std::string> split(const std::string &s, char delim) {`
`53`	`53`	`bool SpeechRecognizerModule::configure(ResourceFinder &rf )`
`54`	`54`	`{`
`55`	`55`	`setName( rf.check("name",Value("speechRecognizer")).asString().c_str() );`
`56`		`- m_timeout = rf.check("timeout",Value(10000)).asInt();`
	`56`	`+ m_timeout = rf.check("timeout",Value(10000)).asInt32();`
`57`	`57`	`USE_LEGACY = !rf.check("noLegacy");`
`58`	`58`	`m_forwardSound = rf.check("forwardSound");`
`59`	`59`	`m_tmpFileFolder = rf.getHomeContextPath();`
`@@ -265,7 +265,7 @@ bool SpeechRecognizerModule::updateModule()`
`265`	`265`	`//Send over yarp`
`266`	`266`	`Bottle bOut;`
`267`	`267`	`bOut.addString(fullSentence);`
`268`		`- bOut.addInt(confidence);`
	`268`	`+ bOut.addInt32(confidence);`
`269`	`269`	`m_portContinuousRecognition.write(bOut);`
`270`	`270`
`271`	`271`	`//Treat the semantic`
`@@ -644,7 +644,7 @@ string SpeechRecognizerModule::getFromDictaction(int timeout, LPCWSTR options )`
`644`	`644`	`for(list< pair<string, double> >::iterator it = results.begin(); it != results.end(); it++)`
`645`	`645`	`{`
`646`	`646`	`botTmp.addString(it->first);`
`647`		`- //botTmp.addDouble(it->second);`
	`647`	`+ //botTmp.addFloat64(it->second);`
`648`	`648`	`}`
`649`	`649`	`}`
`650`	`650`	`yInfo() <<"Dictation is off...";`
`@@ -662,8 +662,8 @@ bool SpeechRecognizerModule::handleRecognitionCmd(const Bottle& cmd, Bottle& rep`
`662`	`662`
`663`	`663`	`if (firstVocab == "timeout")`
`664`	`664`	`{`
`665`		`- m_timeout = cmd.get(1).asInt();`
`666`		`- //reply.addInt(true);`
	`665`	`+ m_timeout = cmd.get(1).asInt32();`
	`666`	`+ //reply.addInt32(true);`
`667`	`667`	`return false;`
`668`	`668`	`}`
`669`	`669`
`@@ -684,7 +684,7 @@ bool SpeechRecognizerModule::handleRecognitionCmd(const Bottle& cmd, Bottle& rep`
`684`	`684`	`for(list< pair<string, double> >::iterator it = results.begin(); it != results.end(); it++)`
`685`	`685`	`{`
`686`	`686`	`reply.addString(it->first);`
`687`		`- reply.addDouble(it->second);`
	`687`	`+ reply.addFloat64(it->second);`
`688`	`688`	`}`
`689`	`689`	`else`
`690`	`690`	`reply.addString("-1");`
`@@ -694,7 +694,7 @@ bool SpeechRecognizerModule::handleRecognitionCmd(const Bottle& cmd, Bottle& rep`
`694`	`694`	`//Turn off dictation and go back to the file grammar`
`695`	`695`	`everythingIsFine &= SUCCEEDED(m_cpGrammarDictation->SetDictationState( SPRS_INACTIVE ));`
`696`	`696`	`everythingIsFine &=SUCCEEDED(m_cpGrammarFromFile->SetGrammarState(SPGS_ENABLED));`
`697`		`- //reply.addInt(true);`
	`697`	`+ //reply.addInt32(true);`
`698`	`698`	`return true;`
`699`	`699`	`}`
`700`	`700`	`// If we are not in dictation then we set and switch to the runtimeGrammar`
`@@ -716,7 +716,7 @@ bool SpeechRecognizerModule::handleRecognitionCmd(const Bottle& cmd, Bottle& rep`
`716`	`716`
`717`	`717`	`refreshFromVocabulories(m_cpGrammarRuntime);`
`718`	`718`
`719`		`- //reply.addInt(everythingIsFine);`
	`719`	`+ //reply.addInt32(everythingIsFine);`
`720`	`720`	`}`
`721`	`721`
`722`	`722`	`else if (firstVocab == "choices")`
`@@ -758,7 +758,7 @@ bool SpeechRecognizerModule::handleRecognitionCmd(const Bottle& cmd, Bottle& rep`
`758`	`758`	`for(list< pair<string, double> >::iterator it = results.begin(); it != results.end(); it++)`
`759`	`759`	`{`
`760`	`760`	`reply.addString(it->first);`
`761`		`- reply.addDouble(it->second);`
	`761`	`+ reply.addFloat64(it->second);`
`762`	`762`	`}`
`763`	`763`	`else`
`764`	`764`	`reply.addString("-1");`
`@@ -882,7 +882,7 @@ void SpeechRecognizerModule::say(string s, bool wait)`
`882`	`882`	`if(wait)`
`883`	`883`	`{`
`884`	`884`	`yarp::os::Bottle cmd,reply;`
`885`		`- cmd.addVocab(VOCAB('s','t','a','t'));`
	`885`	`+ cmd.addVocab32(VOCAB('s','t','a','t'));`
`886`	`886`	`std::string status = "speaking";`
`887`	`887`	`bool speechStarted = false;`
`888`	`888`	`while(wait&&(!speechStarted \|\|status=="speaking"))`
Original file line number	Diff line number	Diff line change
`@@ -82,8 +82,8 @@ bool Speech::open(yarp::os::Searchable &config)`
`82`	`82`	`return false;`
`83`	`83`	`}`
`84`	`84`
`85`		`- setPitch(config.check("pitch",Value(90)).asInt());`
`86`		`- setSpeed(config.check("speed",Value(105)).asInt());`
	`85`	`+ setPitch(config.check("pitch",Value(90)).asInt32());`
	`86`	`+ setSpeed(config.check("speed",Value(105)).asInt32());`
`87`	`87`
`88`	`88`	`lingwareRF.setDefaultContext(config.check("lingware-context",Value("speech")).asString());`
`89`	`89`	`lingwareRF.configure(0,NULL);`