|| || || || || || || ||

---

TextSearchConnector.h

Go to the documentation of this file.

#ifndef Impala_Core_Trec_TextSearchConnector_h
#define Impala_Core_Trec_TextSearchConnector_h

#include <iostream>
#include <queue>

// these two need to be moved somewhere:
#include "Application/videolympics/VideolympicsClient.h"
//#ifndef PRACTICALSOCKETS_LOADED
//#include "Application/videolympics/Link/PracticalSocket.h"
//#include "Application/videolympics/Link/PracticalSocket.cpp"
//#define PRACTICALSOCKETS_LOADED

#include "Util/StringParser.h"
#include "Basis/CmdOptions.h"
#include "Core/VideoSet/Segmentation.h"
#include "Core/Trec/ShotResult.h"

namespace Impala {
namespace Core {
namespace Trec {

class TextSearchConnector
{
public:
    TextSearchConnector(VideoSet::Segmentation *seg)
    {
        CmdOptions& options = CmdOptions::GetInstance();
        mTextServer = options.GetString("textServer");
        mTextPort = options.GetInt("textPort");
        mConnected = false;
        mHasResults = false;
        mSegmentation = seg;
    }

    void Connect()
    {
        if (mConnected)
            return;
        ILOG_DEBUG("establishing connection... ");
        try {
            mSocket = new TCPSocket(mTextServer, mTextPort);
        } catch (SocketException e) {
            ILOG_DEBUG("Could not connect to server.");
            mConnected = false;
            return;
        }
        mConnected = true;
        ILOG_DEBUG("connection established.");
    }

    void Query(std::string q)
    {
        ILOG_DEBUG("Query: " << q);
        mHasResults = false;
        if (!mConnected)
            Connect();

        if (!mConnected)
            return;

        q = q + '\n';

        ILOG_DEBUG("Sending query...");
        try {
            mSocket->send(q.c_str(), strlen(q.c_str()));
        } catch (SocketException e) {
            ILOG_ERROR("Server connection failed during SEND.");
            mConnected = false;
            return;
        }
        ILOG_DEBUG("query sent.");

        int rem = 0;
        char buffer[20000];
        for (int i=0; i < 20000; i++) buffer[i]=0;
        char *pos = buffer;

        std::vector<std::string> results;
        try {
            while (true) {
                int beetje = mSocket->recv(pos, 20000 - rem);
                rem += beetje;
                pos = &buffer[rem];
                if (rem >= 20000)
                {
                    ILOG_ERROR("Out of buffer memory while retrieving results.");
                    return;
                }
                results = tokenize(std::string(buffer));
                // temp bugfix: in Windows the tokenization adds more than just
                // 'DONE'. Since DONE is the only statement ever sent from the
                // text server starting with a D we can also just look for that
                // - Ork
                if (results.size() > 0 && results[results.size()-1][0] == 'D')
                {
                    break;
                } 
                if (results.size() > 0 && results[results.size()-1] == "DONE")
                {
                    break;
                }
            }
        } catch (SocketException e) {
            ILOG_ERROR("Server connection failed during RECV.");
            mConnected = false;
            return;
        }
        results = tokenize(std::string(buffer));
        if (results.size() == 1 && results[0] == "DONE")
        {
            ILOG_INFO("No text results found.");
            mHasResults = false;
            return;
        }

        int found = 0, i=0;
        int number = results.size() / 6;
        ILOG_DEBUG("Number of results: " << number);

        mResults.clear();
        int rank = 1;
        while (found < number) {
            if (results[i] == "DONE")
                break;
            Core::Trec::ShotResult r;
            r.shotid = mSegmentation->GetShotId(results[i+2]);
            ILOG_DEBUG("Found text result " << rank << " : " << results[i+2] << " score " << results[i+4]);
            r.rank = rank++;
            r.score = atof(results[i+4]);
            mResults.push_back(r);
            i+=6;
            found++;
        }
        mHasResults = true;
        return;
    }

    bool
    HasResults()
    {
        return mHasResults;
    }

    std::list<Core::Trec::ShotResult> GetResults()
    {
        return mResults;
    }

private:

    std::vector<std::string> tokenize(const std::string& input, const std::string& delims = " \n")
    {
        std::string::size_type lPos = input.find_first_not_of(delims, 0);
        std::string::size_type pos = input.find_first_of(delims, lPos);

        std::vector<std::string> tokens;

        while (std::string::npos != pos || std::string::npos != lPos)
        {
            tokens.push_back(input.substr(lPos, pos-lPos));
            lPos = input.find_first_not_of(delims, pos);
            pos = input.find_first_of(delims, lPos);
        }

        return tokens;
    }

    std::string mTextServer;
    int         mTextPort;

    TCPSocket   *mSocket;

    bool        mConnected;
    bool        mHasResults;

    VideoSet::Segmentation *mSegmentation;

    std::list<Core::Trec::ShotResult> mResults;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(TextSearchConnector, Core.Trec);


}
}
}

#endif

---