shared_recognition_results_manager.cpp

Go to the documentation of this file.

//Local includes
#include "asr_recognizer_prediction_ism/shared_recognition_results_manager.h"
#include <ros/ros.h>

using namespace std;
using namespace ISM;

namespace recognizer_prediction_ism
{

bool SharedRecognitionResultsManager::addResults(std::vector<ISM::RecognitionResultPtr> &result_ptrs)
{
    mutex_.lock();
    shared_memory_vector_.insert(shared_memory_vector_.end(), result_ptrs.begin(), result_ptrs.end());
    ROS_DEBUG_STREAM_NAMED("SharedMemory", "Added: " << result_ptrs.size() << " recognitionresults to shared memory, now containing "  << shared_memory_vector_.size() << " recognitionresults");
    mutex_.unlock();
    return true;
}

RecognitionResult SharedRecognitionResultsManager::getLastResult()
{
    ROS_DEBUG_STREAM_NAMED("SharedMemory", "Returning last recognitionresults");
    return *shared_memory_vector_.back();
}

std::vector<RecognitionResultPtr> SharedRecognitionResultsManager::getResults()
{

    std::vector<RecognitionResultPtr> results;

    mutex_.lock();
    //This should may copy all Recognition Results!!!
    for (std::vector<RecognitionResultPtr>::iterator it = shared_memory_vector_.begin(); it != shared_memory_vector_.end(); it++)
        results.push_back(*it);

    ROS_DEBUG_STREAM_NAMED("SharedMemory", "Returning all (" << shared_memory_vector_.size() << ") recognitionresults");

    mutex_.unlock();

    return results;

}

unsigned int SharedRecognitionResultsManager::getResultsNumber()
{
    ROS_DEBUG_STREAM_NAMED("SharedMemory", "Returning size of shared memory");
    return shared_memory_vector_.size();
}

void SharedRecognitionResultsManager::clearResults()
{
    mutex_.lock();
    shared_memory_vector_.clear();
    ROS_DEBUG_STREAM_NAMED("SharedMemory", "Cleared shared memory, now containing "  << shared_memory_vector_.size() << " recognitionresults");
    mutex_.unlock();
}

bool SharedRecognitionResultsManager::recognitionResultsAvailable()
{
    return !shared_memory_vector_.empty();
}

bool SharedRecognitionResultsManager::popLastResult()
{
    mutex_.lock();

    if (!shared_memory_vector_.empty())
        shared_memory_vector_.pop_back();
    else
        return false;
    mutex_.unlock();

    ROS_DEBUG_STREAM_NAMED("SharedMemory", "Popped last recognitionresult, now containing "  << shared_memory_vector_.size() << " recognitionresults");
    return true;
}
std::ostream& operator<<(std::ostream &strm, SharedRecognitionResultsManager &p){
    stringstream s;
    std::vector<RecognitionResultPtr> rr_vec = p.getResults();
    s << "[SharedMemory:size=" << rr_vec.size() <<";vector:[";
    for(RecognitionResultPtr r : rr_vec){
       s << r << ",";
    }
    s << "]]";
    return strm << s.str();
}

std::ostream& operator<<(std::ostream &strm, const SharedRecognitionResultsManagerPtr &pPtr){
    return strm << (*pPtr);
}
}