/home/palakars/workspace-inprogress/code-in-progress/aitools3/aitools3-aq-invertedindex-cpp/src/core/IndexSearcher.hpp

Go to the documentation of this file.

/* Copyright (C) 2010 webis.de
 * All rights reserved.
 */
#ifndef AITOOLS_INVERTEDINDEX_INDEX_SEARCHER_HPP
#define AITOOLS_INVERTEDINDEX_INDEX_SEARCHER_HPP

#include "Logging.hpp"
#include "Searcher.hpp"
#include "Checksum.hpp"
#include "Postlist.hpp"
#include "Converter.hpp"
#include "Exception.hpp"
#include "IndexBuilder.hpp"
#include "StorageSearcher.hpp"
#include <boost/algorithm/string.hpp>
#include <boost/filesystem/fstream.hpp>

namespace aitools {
namespace invertedindex {

template<typename Value>
class IndexSearcher : public Searcher {

public: // class data

        static const std::string header_file;

public: // c'tor / d'tor

        IndexSearcher();

        ~IndexSearcher();

private: // class member

        static void check_config(const Configuration& config)
        throw (std::invalid_argument);

public: // member

        void dashboard(std::ostream& os) const;

        void init(const Configuration& config)
        throw (std::runtime_error, std::logic_error);

        Iterator::SharedPointer
        generic_search(const std::string& key)
        throw (std::runtime_error);

        Iterator::SharedPointer
        generic_search(const std::string& key, Quantile::Order order)
        throw (std::runtime_error);

        Iterator::SharedPointer
        generic_search(const std::string& key, size_t length)
        throw (std::runtime_error);

        Postlist<Value>
        search(const std::string& key) throw (std::runtime_error);

        Postlist<Value>
        search(const std::string& key, Quantile::Order order)
        throw (std::runtime_error);

        Postlist<Value>
        search(const std::string& key, size_t length)
        throw (std::runtime_error);

        const Quantile& quantile(const std::string& key) const;

        const Vocabulary& vocabulary() const;

        const MPHashFunction& mphf() const;

        const Header& header() const;

private: // data

        StorageSearcher storage_;
        Header          header_;

};

// IMPLEMENTATION

template<typename Value>
const std::string
IndexSearcher<Value>::header_file(IndexBuilder<Value>::header_file);

template<typename Value>
IndexSearcher<Value>::IndexSearcher()
{}

template<typename Value>
IndexSearcher<Value>::~IndexSearcher()
{}

template<typename Value>
void
IndexSearcher<Value>::check_config(const Configuration& config)
throw (std::invalid_argument)
{
        if (!bfs::exists(config.index_directory()))
        {
                std::string msg("Does not exist");
                Exception::throw_invalid_argument(msg, config.index_directory());
        }
        if (bfs::is_empty(config.index_directory()))
        {
                std::string msg("Is empty");
                Exception::throw_invalid_argument(msg, config.index_directory());
        }
}

template<typename Value>
void
IndexSearcher<Value>::dashboard(std::ostream& os) const
{
        os << header_.DebugString();
}

template<typename Value>
void
IndexSearcher<Value>::init(const Configuration& config)
throw (std::runtime_error, std::logic_error)
{
        check_config(config);

        // load header
        bfs::path file(bfs::path(config.index_directory()) / header_file);
        bfs::ifstream stream(file, std::ios::binary);
        if (!stream)
        {
                Exception::throw_invalid_argument("Cannot open", file);
        }
        else if (!header_.ParseFromIstream(&stream))
        {
                Exception::throw_runtime_error("Cannot deserialize header");
        }
        stream.close();

        // check version
        if (header_.major_version() != INDEX_VERSION_MAJOR ||
                header_.minor_version() != INDEX_VERSION_MINOR)
        {
                std::ostringstream oss;
                oss << "You need to have aitools-invertedindex-"
                        << INDEX_VERSION_MAJOR << '.' << INDEX_VERSION_MINOR
                        << " to be installed.";
                Exception::throw_domain_error("Version conflict: " + oss.str());
        }

        // check value class name
        if (header_.value_class_name() != Value::classname)
        {
                std::string msg("Has to be " + header_.value_class_name());
                Exception::throw_domain_error("Wrong value type: " + msg);
        }

        storage_.open(config.index_directory());
}

template<typename Value>
Iterator::SharedPointer
IndexSearcher<Value>::generic_search(const std::string& key)
throw (std::runtime_error)
{
        return generic_search(key, INT_MAX);
}

template<typename Value>
Iterator::SharedPointer
IndexSearcher<Value>::generic_search
(const std::string& key, Quantile::Order order) throw (std::runtime_error)
{
        return generic_search(key, quantile(key).get(order));
}

template<typename Value>
Iterator::SharedPointer
IndexSearcher<Value>::generic_search(const std::string& key, size_t length)
throw (std::runtime_error)
{
        Iterator::SharedPointer iterator(storage_.get(key, length));
        if (iterator->is_valid() &&
                iterator->header().checksum != Checksum::hash16(key))
        {
                std::ostringstream msg;
                msg << "key checksum = " << Checksum::hash16(key)
                        << ", iterator checksum = " << iterator->header().checksum;
                Logging::debug("checksum mismatch", msg.str());
                iterator.reset(new Iterator);
        }
        return iterator;
}

template<typename Value>
Postlist<Value>
IndexSearcher<Value>::search(const std::string& key) throw (std::runtime_error)
{
        return Postlist<Value>(generic_search(key, INT_MAX));
}

template<typename Value>
Postlist<Value>
IndexSearcher<Value>::search(const std::string& key, Quantile::Order order)
throw (std::runtime_error)
{
        return Postlist<Value>(generic_search(key, quantile(key).get(order)));
}

template<typename Value>
Postlist<Value>
IndexSearcher<Value>::search(const std::string& key, size_t length)
throw (std::runtime_error)
{
        return Postlist<Value>(generic_search(key, length));
}

template<typename Value>
const Quantile&
IndexSearcher<Value>::quantile(const std::string& key) const
{
        return storage_.quantile(key);
}

template<typename Value>
const Vocabulary&
IndexSearcher<Value>::vocabulary() const
{
        return storage_.vocabulary();
}

template<typename Value>
const MPHashFunction&
IndexSearcher<Value>::mphf() const
{
        return storage_.mphf();
}

template<typename Value>
const Header&
IndexSearcher<Value>::header() const
{
        return header_;
}

} // namespace invertedindex
} // namespace aitools

#endif // AITOOLS_INVERTEDINDEX_INDEX_SEARCHER_HPP

---