/Users/dbr/ma/src/lmu/cis/sis/indexer/DocumentIndexingAutomatonFindResults.hpp

Go to the documentation of this file.

#ifndef DOCUMENTINDEXINGAUTOMATONFINDRESULTS_HPP
#define DOCUMENTINDEXINGAUTOMATONFINDRESULTS_HPP

#include "../cppbase.hpp"
#include "../adapter/CompressedAutomatonAdapter.hpp"
// #include "DocumentIndexingAutomaton.hpp"

// using lmu::cis::sis::DocumentIndexingAutomaton;
#include <iostream>
#include <set>
#include <map>
#include <vector>
#include <string>
#include <deque>
#include <tuple>
#include <algorithm>
#include <list>
#include <regex>

namespace lmu { namespace cis { namespace sis {

typedef std::string                                 DocumentName;
// typedef UINT                                        RelativePosition;
// typedef UINT                                        AbsolutePosition;
typedef std::tuple<
                DocumentName,
                RelativeDocumentPosition,
                AbsoluteDocumentPosition,
                ActualDocumentPosition>             ResultsTuple;
typedef std::list<ResultsTuple>                   ResultsList;
// typedef std::pair<DocumentName, PositionsTupleContainer>    ResultsMapIterator;


// template<typename T>
class DocumentIndexingAutomatonFindResults {
protected:
    ResultsList results_;
    ResultsList::const_iterator curr_it_;
    const CompressedAutomatonAdapter& aut_;
public:

    // DocumentIndexingAutomatonFindResults() = default; ///< Set to default
    DocumentIndexingAutomatonFindResults(CompressedAutomatonAdapter* automaton_)
        : results_()
        , curr_it_()
        , aut_(*automaton_)
        {
        }
    virtual ~DocumentIndexingAutomatonFindResults() = default; 

    // Methods.
    virtual
    DocumentIndexingAutomatonFindResults&
    insert_position(const DocumentName& doc, const PositionsTuple& p) {
        results_.push_back( std::tuple_cat(std::make_tuple(doc), p) );
        return *this;
    }

    virtual inline ResultsList::const_iterator begin()  { results_.sort(); curr_it_ = results_.cbegin(); return curr_it_; }
    virtual inline ResultsList::const_iterator end()    { curr_it_ = results_.cend(); return curr_it_; }
    virtual inline ResultsList::const_iterator cbegin() { return begin(); }
    virtual inline ResultsList::const_iterator cend()   { return end(); }
    virtual inline size_t size() const { return results_.size(); }
    virtual inline bool empty()  const { return size() == 0; }
    virtual inline DocumentName    document_name(ResultsList::const_iterator it) { return std::get<0>(*it); }
    virtual inline DocumentPosition relative_pos(ResultsList::const_iterator it) { return std::get<1>(*it); }
    virtual inline DocumentPosition absolute_pos(ResultsList::const_iterator it) { return std::get<2>(*it); }
    virtual inline DocumentPosition actual_pos  (ResultsList::const_iterator it) { return std::get<3>(*it); }
    virtual inline std::string        lr_context(ResultsList::const_iterator it, UINT width = 20) {
        std::string res;
        UINT pos = actual_pos(it);

        mSymbolAndVariables( zero )
        mSymbolAndVariables( one )
        mSymbolAssignValue( zero, 0, aut_.get_symbol_size() )
        mSymbolAssignValue( one, 1, aut_.get_symbol_size() )

        if (width > pos) {
            for (auto i = width - pos; i > 0; i--)
                res.append( aut_.data_at(i) );
        }
        for (auto i = width > pos ? 0 : pos - width; i < pos+width; i++) { // make sure the unsigned ints start from 0.
            std::string s = aut_.data_at(i);
            if ( (memcmp(zero, s.data(), 1) == 0) ) {
                std::cout << "HIT LEFT BORDER." << std::endl;
                i = 0;
            }
            if ( (memcmp(one, s.data(), 1) == 0) ) {
                std::cout << "HIT RIGHT BORDER." << std::endl;
                i = pos+width; // break.
            }
            res.append( s );
        }
        return std::forward<std::string>(res);
    }


    virtual inline DocumentName    document_name(ResultsTuple it) { return std::get<0>(it); }
    virtual inline DocumentPosition relative_pos(ResultsTuple it) { return std::get<1>(it); }
    virtual inline DocumentPosition absolute_pos(ResultsTuple it) { return std::get<2>(it); }
    virtual inline DocumentPosition actual_pos  (ResultsTuple it) { return std::get<3>(it); }
    virtual inline std::string        lr_context(ResultsTuple it, UINT width = 20) {
        // a lot of alignment happens here. for now there are small off-by-one's in
        // there but i don't care.
        std::string res;

        // get the actual position in the long data string
        UINT pos = actual_pos(it);

        // get those # and $ thingies to test on them
        mSymbolAndVariables( zero )
        mSymbolAndVariables( one )
        mSymbolAssignValue( zero, 0, aut_.get_symbol_size() )
        mSymbolAssignValue( one, 1, aut_.get_symbol_size() )

        // declare our maximum boundaries to the left and right
        UINT max_left  = 0;
        UINT max_right = 0;

        if (DEBUG_LEVEL >= 5) std::cerr << "pos: " << pos << std::endl;

        // find the left boundary: either '#' or width chars away from pos
        for (auto i = pos; i != 0 && i > pos-width-1; i--) {
            if (memcmp(zero, aut_.data_at(i).data(), 1) == 0) break;
            max_left = i+1;
        }
        if (max_left == 0) max_left = 1; // dunno. just set it back.

        // find the right border
        for (auto i = pos; i <= (pos + width) && i <= aut_.data_length(); i++) {
            if (memcmp(one, aut_.data_at(i).data(), 1) == 0) break;
            max_right = i;
        }
        if (! max_right == aut_.data_length() ) max_right++;

        // printf debugging...
        if (DEBUG_LEVEL >= 5) std::cerr << "left: " << max_left << std::endl;
        if (DEBUG_LEVEL >= 5) std::cerr << "right: " << max_right << std::endl;

        // insert some blanks or whatever to get a nicely layed out concordance view
        if ( width > (pos-max_left) ) res.append( (width - (pos - max_left)), ' ');

        // append the found data
        for (auto i = max_left; i < max_right; i++) {
            res.append( aut_.data_at(i) );
        }
        // append blanks to the right again.
        if ( width > max_right-pos ) res.append( (width - (max_right - pos)), ' ');

        // std::string res2;
        // try {
        // std::regex rx(R"([\t\n])");
        // std::string replacement(" ");
        //     res2 = std::regex_replace(res, rx, replacement);
        // } catch (std::regex_error& e) {
        //     std::cerr << "Caught exception: " << e.code() << std::endl;
        // }
        std::replace (res.begin(), res.end(), '\n', ' ');
        return std::forward<std::string>(res);
    }

}; /* End of class DocumentIndexingAutomatonFindResults */

}}} /* End of namespace lmu::cis::sis */

#endif /* end of include guard: DOCUMENTINDEXINGAUTOMATONFINDRESULTS_HPP */