Open Source Projects Europe

    :  m_wcount(0), m_hdata(hdata)

    :  m_wcount(0), m_hdata(hdata)

    {

    {

    // We separate single terms and groups and extract the group

    // We separate single terms and groups and extract the group

    // terms for computing positions list before looking for group

    // terms for computing positions list before looking for group

    // matches

    // matches

    for (vector<vector<string> >::const_iterator vit = hdata.groups.begin();

    for (vector<vector<string> >::const_iterator vit = hdata.groups.begin();

         vit != hdata.groups.end(); vit++) {

         vit != hdata.groups.end(); vit++) {

        if (vit->size() == 1) {

        if (vit->size() == 1) {

        m_terms[vit->front()] = vit - hdata.groups.begin();

        } else if (vit->size() > 1) {

        } else if (vit->size() > 1) {

        for (vector<string>::const_iterator it = vit->begin(); 

        for (vector<string>::const_iterator it = vit->begin(); 

             it != vit->end(); it++) {

             it != vit->end(); it++) {

            m_gterms.insert(*it);

            m_gterms.insert(*it);

        }

        }

        }

        }

    }

    }

    }

    }

    // Accept word and its position. If word is search term, add

    // Accept word and its position. If word is search term, add

    // highlight zone definition. If word is part of search group

    // highlight zone definition. If word is part of search group

    // (phrase or near), update positions list.

    // (phrase or near), update positions list.

    virtual bool takeword(const std::string& term, int pos, int bts, int bte) {

    virtual bool takeword(const std::string& term, int pos, int bts, int bte) {

    string dumb;

    if (!unacmaybefold(term, dumb, "UTF-8", UNACOP_UNACFOLD)) {

    }

    }

    //LOGDEB2(("Input dumbbed term: '%s' %d %d %d\n", dumb.c_str(), 

    //LOGDEB2(("Input dumbbed term: '%s' %d %d %d\n", dumb.c_str(), 

    // pos, bts, bte));

    // pos, bts, bte));

    // If this word is a search term, remember its byte-offset span. 

    // If this word is a search term, remember its byte-offset span. 

    map<string, unsigned int>::const_iterator it = m_terms.find(dumb);

    map<string, unsigned int>::const_iterator it = m_terms.find(dumb);

//    make no sense for highlighting.

//    make no sense for highlighting.

static bool do_proximity_test(int window, vector<vector<int>* >& plists, 

static bool do_proximity_test(int window, vector<vector<int>* >& plists, 

                  unsigned int i, int min, int max, 

                  unsigned int i, int min, int max, 

                  int *sp, int *ep, int minpos)

                  int *sp, int *ep, int minpos)

{

{

         window, i, min, max, minpos));

         window, i, min, max, minpos));

    int tmp = max + 1 - window;

    int tmp = max + 1 - window;

    if (tmp < minpos)

    if (tmp < minpos)

    tmp = minpos;

    tmp = minpos;

bool TextSplitPTR::matchGroup(unsigned int grpidx)

bool TextSplitPTR::matchGroup(unsigned int grpidx)

{

{

    const vector<string>& terms = m_hdata.groups[grpidx];

    const vector<string>& terms = m_hdata.groups[grpidx];

    int window = m_hdata.groups[grpidx].size() + m_hdata.slacks[grpidx];

    int window = m_hdata.groups[grpidx].size() + m_hdata.slacks[grpidx];

        vecStringToString(terms).c_str()));

        vecStringToString(terms).c_str()));

    // The position lists we are going to work with. We extract them from the 

    // The position lists we are going to work with. We extract them from the 

    // (string->plist) map

    // (string->plist) map

    vector<vector<int>* > plists;

    vector<vector<int>* > plists;

    // the search, so that some terms are not found.

    // the search, so that some terms are not found.

    for (vector<string>::const_iterator it = terms.begin(); 

    for (vector<string>::const_iterator it = terms.begin(); 

     it != terms.end(); it++) {

     it != terms.end(); it++) {

    map<string, vector<int> >::iterator pl = m_plists.find(*it);

    map<string, vector<int> >::iterator pl = m_plists.find(*it);

    if (pl == m_plists.end()) {

    if (pl == m_plists.end()) {

            (*it).c_str()));

            (*it).c_str()));

        return false;

        return false;

    }

    }

    plists.push_back(&(pl->second));

    plists.push_back(&(pl->second));

    plistToTerm[&(pl->second)] = *it;

    plistToTerm[&(pl->second)] = *it;

    }

    }

    // I think this can't actually happen, was useful when we used to

    // I think this can't actually happen, was useful when we used to

    // prune the groups, but doesn't hurt.

    // prune the groups, but doesn't hurt.

    if (plists.size() < 2) {

    if (plists.size() < 2) {

    return false;

    return false;

    }

    }

    // Sort the positions lists so that the shorter is first

    // Sort the positions lists so that the shorter is first

    std::sort(plists.begin(), plists.end(), VecIntCmpShorter());

    std::sort(plists.begin(), plists.end(), VecIntCmpShorter());

    if (it == plistToTerm.end()) {

    if (it == plistToTerm.end()) {

        // SuperWeird

        // SuperWeird

        LOGERR(("matchGroup: term for first list not found !?!\n"));

        LOGERR(("matchGroup: term for first list not found !?!\n"));

        return false;

        return false;

    }

    }

        it->second.c_str(), plists[0]->size()));

        it->second.c_str(), plists[0]->size()));

    }

    }

    // Minpos is the highest end of a found match. While looking for

    // Minpos is the highest end of a found match. While looking for

    // further matches, we don't want the search to extend before

    // further matches, we don't want the search to extend before

    // Walk the shortest plist and look for matches

    // Walk the shortest plist and look for matches

    for (vector<int>::iterator it = plists[0]->begin(); 

    for (vector<int>::iterator it = plists[0]->begin(); 

     it != plists[0]->end(); it++) {

     it != plists[0]->end(); it++) {

    int pos = *it;

    int pos = *it;

    int sta = int(10E9), sto = 0;

    int sta = int(10E9), sto = 0;

    if (do_proximity_test(window,plists, 1, pos, pos, &sta, &sto, minpos)) {

    if (do_proximity_test(window,plists, 1, pos, pos, &sta, &sto, minpos)) {

             sta, sto)); 

             sta, sto)); 

        // Maybe extend the window by 1st term position, this was not

        // Maybe extend the window by 1st term position, this was not

        // done by do_prox..

        // done by do_prox..

        SETMINMAX(pos, sta, sto);

        SETMINMAX(pos, sta, sto);

        minpos = sto+1;

        minpos = sto+1;

        // Translate the position window into a byte offset window

        // Translate the position window into a byte offset window

        map<int, pair<int, int> >::iterator i1 =  m_gpostobytes.find(sta);

        map<int, pair<int, int> >::iterator i1 =  m_gpostobytes.find(sta);

        map<int, pair<int, int> >::iterator i2 =  m_gpostobytes.find(sto);

        map<int, pair<int, int> >::iterator i2 =  m_gpostobytes.find(sto);

        if (i1 != m_gpostobytes.end() && i2 != m_gpostobytes.end()) {

        if (i1 != m_gpostobytes.end() && i2 != m_gpostobytes.end()) {

            i1->second.first, i2->second.second));

            i1->second.first, i2->second.second));

        tboffs.push_back(MatchEntry(i1->second.first, 

        tboffs.push_back(MatchEntry(i1->second.first, 

                        i2->second.second, grpidx));

                        i2->second.second, grpidx));

        } else {

        } else {

        LOGDEB(("matchGroup: no bpos found for %d or %d\n", sta, sto));

        }

        }

    } else {

    } else {

        LOGDEB1(("matchGroup: no group match found at this position\n"));

        LOGDEB1(("matchGroup: no group match found at this position\n"));

    }

    }

    }

    }

                  list<string>& out, // Output chunk list

                  list<string>& out, // Output chunk list

                  const HighlightData& hdata,

                  const HighlightData& hdata,

                  int chunksize)

                  int chunksize)

{

{

    Chrono chron;

    Chrono chron;

    m_hdata = &hdata;

    m_hdata = &hdata;

    // Compute the positions for the query terms.  We use the text

    // Compute the positions for the query terms.  We use the text

    // splitter to break the text into words, and compare the words to

    // splitter to break the text into words, and compare the words to

    // the search terms,

    // the search terms,

    out.push_back("");

    out.push_back("");

    list<string>::iterator olit = out.begin();

    list<string>::iterator olit = out.begin();

    // Rich text output

    // Rich text output

    *olit = header();

    *olit = header();

    // Iterator for the list of input term positions. We use it to

    // Iterator for the list of input term positions. We use it to

    // output highlight tags and to compute term positions in the

    // output highlight tags and to compute term positions in the

    // output text

    // output text

    vector<MatchEntry>::iterator tPosIt = splitter.tboffs.begin();

    vector<MatchEntry>::iterator tPosIt = splitter.tboffs.begin();

    fprintf(fp, "ENDOFPLAINTORICHOUTPUT\n");

    fprintf(fp, "ENDOFPLAINTORICHOUTPUT\n");

    fclose(fp);

    fclose(fp);

    }

    }

#endif

#endif

    LOGDEB2(("plaintorich: done %d mS\n", chron.millis()));

    LOGDEB2(("plaintorich: done %d mS\n", chron.millis()));

}

}