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

Go to the documentation of this file.

#include "StorageSearcher.hpp"
#include "Converter.hpp"
#include "Logging.hpp"
#include "System.hpp"

namespace aitools {
namespace invertedindex {

const Quantile
StorageSearcher::empty_quantile;

StorageSearcher::StorageSearcher()
{}

StorageSearcher::~StorageSearcher()
{}

void
StorageSearcher::close()
{
        readers_.clear();
}

bool
StorageSearcher::is_open() const
{
        return !readers_.empty();
}

void
StorageSearcher::open(const bfs::path& directory) throw (std::invalid_argument)
{
        // load hash function and vocabulary
        hash_func_.load(directory / StorageBuilder::mphf_file);
        vocabulary_.load(directory / StorageBuilder::vocab_file);
        unsigned table_size(hash_func_.size());

        // load postlist location table
        locations_.resize(table_size);
        FILE* storage(System::fopen(directory/StorageBuilder::storage_file, "rb"));
        System::fread(locations_.data(), sizeof(Location), table_size, storage);
        std::fclose(storage);

        // load quantiles if any
        bfs::path path(directory / StorageBuilder::quantile_file);
        if (bfs::exists(path))
        {
                FILE* quantile(System::fopen(path, "rb"));
                quantiles_.resize(table_size);
                System::fread(quantiles_.data(), Quantile::size, table_size, quantile);
                std::fclose(quantile);
        }

        // open postlist files
        std::string id;
        unsigned num(std::max_element(locations_.begin(), locations_.end())->first);
        for (unsigned i(0); i <= num; ++i)
        {
                id = Converter::ui32_to_str(i);
                readers_.push_back(Reader(new PostlistReader));
                readers_.back()->open(directory / (StorageBuilder::data_file + id));
        }
}

Iterator::SharedPointer
StorageSearcher::get(const std::string& key) throw (std::runtime_error)
{
        return get(key, INT_MAX);
}

Iterator::SharedPointer
StorageSearcher::get(const std::string& key, size_t length)
throw (std::runtime_error)
{
        if (!vocabulary_.contains(key))
        {
                return Iterator::SharedPointer(new Iterator);
        }
        Location location(locations_[hash_func_.hash(key)]);
        boost::mutex::scoped_lock lock(mutex_);
        readers_[location.first]->seek(location.second);
        return readers_[location.first]->read(length);
        // the mutex is unlocked automatically
}

Iterator::SharedPointer
StorageSearcher::get(const std::string& key, Quantile::Order order)
throw (std::runtime_error)
{
        return get(key, quantile(key).get(order));
}

const Quantile&
StorageSearcher::quantile(const std::string& key) const
{
        if (!vocabulary_.contains(key) || quantiles_.empty())
        {
                return empty_quantile;
        }
        return quantiles_[hash_func_.hash(key)];
}

const Vocabulary&
StorageSearcher::vocabulary() const
{
        return vocabulary_;
}

const MPHashFunction&
StorageSearcher::mphf() const
{
        return hash_func_;
}

} // namespace invertedindex
} // namespace aitools

---