concordia.hpp

#ifndef CONCORDIA_HDR
#define CONCORDIA_HDR

#include <string>
#include <vector>
#include <boost/shared_ptr.hpp>
#include <boost/filesystem.hpp>

#include "concordia/common/config.hpp"
#include "concordia/example.hpp"
#include "concordia/matched_pattern_fragment.hpp"
#include "concordia/concordia_config.hpp"
#include "concordia/concordia_index.hpp"
#include "concordia/index_searcher.hpp"
#include "concordia/concordia_search_result.hpp"
#include "concordia/tokenized_sentence.hpp"
#include "concordia/anubis_search_result.hpp"
#include <divsufsort.h>


class Concordia {
public:
    Concordia();

    explicit Concordia(const std::string & indexPath,
                       const std::string & configFilePath)
                                         throw(ConcordiaException);
    virtual ~Concordia();

    std::string & getVersion();

    TokenizedSentence tokenize(const std::string & sentence,
                               bool byWhitespace = false,
                               bool generateCodes = true)
                                                     throw(ConcordiaException);

    std::vector<TokenizedSentence> tokenizeAll(
                                   const std::vector<std::string> & sentences,
                                   bool byWhitespace = false,
                                   bool generateCodes = true)
                                                     throw(ConcordiaException);

    TokenizedSentence addExample(const Example & example)
                                          throw(ConcordiaException);

    void addTokenizedExample(
                    const TokenizedSentence & tokenizedSentence,
                    const SUFFIX_MARKER_TYPE id)
                                                  throw(ConcordiaException);

    void addAllTokenizedExamples(
                    const std::vector<TokenizedSentence> & tokenizedSentences,
                    const std::vector<SUFFIX_MARKER_TYPE> & ids)
                                                  throw(ConcordiaException);

    std::vector<TokenizedSentence> addAllExamples(
                                const std::vector<Example> & examples)
                                throw(ConcordiaException);

    MatchedPatternFragment simpleSearch(const std::string & pattern,
                                          bool byWhitespace = false)
                                          throw(ConcordiaException);

    MatchedPatternFragment lexiconSearch(const std::string & pattern,
                                        bool byWhitespace = false)
                                        throw(ConcordiaException);

    SUFFIX_MARKER_TYPE countOccurences(const std::string & pattern)
                                          throw(ConcordiaException);

    std::vector<AnubisSearchResult> anubisSearch(const std::string & pattern)
                                                 throw(ConcordiaException);

    boost::shared_ptr<ConcordiaSearchResult> concordiaSearch(
                                                 const std::string & pattern,
                                                 bool byWhitespace = false)
                                                 throw(ConcordiaException);

    void loadRAMIndexFromDisk() throw(ConcordiaException);

    void refreshSAfromRAM() throw(ConcordiaException);

    void clearIndex() throw(ConcordiaException);

private:
    std::string _getWordMapFilePath();

    std::string _getHashedIndexFilePath();

    std::string _getMarkersFilePath();

    void _initializeIndex() throw(ConcordiaException);

    static std::string _libraryVersion;

    std::string _indexPath;

    boost::shared_ptr<ConcordiaConfig> _config;

    boost::shared_ptr<ConcordiaIndex> _index;

    boost::shared_ptr<IndexSearcher> _searcher;

    boost::shared_ptr<HashGenerator> _hashGenerator;

    boost::shared_ptr<std::vector<sauchar_t> > _T;

    boost::shared_ptr<std::vector<saidx_t> > _SA;

    boost::shared_ptr<std::vector<SUFFIX_MARKER_TYPE> > _markers;
};

#endif