/home/palakars/workspace-inprogress/code-in-progress/aitools3/aitools3-aq-invertedindex-cpp/src/reader/PostlistReader.cpp

Go to the documentation of this file.

#include "PostlistReader.hpp"
#include "System.hpp"

namespace aitools {
namespace invertedindex {

PostlistReader::PostlistReader()
:       file_(NULL)
{}

PostlistReader::PostlistReader(const bfs::path& path)
throw (std::invalid_argument)
:       file_(NULL)
{
        open(path);
}

PostlistReader::~PostlistReader()
{
        close();
}

void
PostlistReader::close()
{
        if (is_open())
        {
                path_ = bfs::path();
                System::fclose(file_);
                file_ = NULL;
        }
}

void
PostlistReader::open(const bfs::path& path)
throw (std::runtime_error, std::invalid_argument)
{
        if (is_open())
        {
                Exception::throw_runtime_error("File already open");
        }
        file_ = System::fopen(path, "rb");
        path_ = path;
}

const bfs::path&
PostlistReader::path() const
{
        return path_;
}

Iterator::SharedPointer
PostlistReader::read(size_t length) throw (std::runtime_error)
{
        // Load postlist header
        Iterator::Header header;
        System::fread(&header, sizeof(header), 1, file_);
        long end_of_postlist(System::ftell(file_) + header.payload);
        const size_t org_value_count(header.value_count);
        if (length < header.value_count)
        {
                header.value_count = length;
                header.payload = header.value_count * header.value_size;
        }
        Iterator::SizeVector* vsizes(new Iterator::SizeVector);
        if (header.value_count != 0 && header.value_size == 0) // load entry sizes
        {
                header.payload = 0;
                vsizes->resize(header.value_count);
                long end_of_header(System::ftell(file_));
                end_of_postlist += org_value_count * sizeof_value_size_t;
                System::fread(vsizes->data(), sizeof_value_size_t, vsizes->size(), file_);
                for (unsigned i = 0; i != header.value_count; ++i)
                {
                        header.payload += (*vsizes)[i];
                }
                long end_of_vsizes(end_of_header + org_value_count * sizeof_value_size_t);
                System::fseek(file_, end_of_vsizes, SEEK_SET);
        }

        // load data
        Iterator::SharedPointer iterator;
        if (header.payload > Iterator::max_chunk_size)
        {
                FILE* file(System::fopen(path_, "rb"));
                System::fseek(file, System::ftell(file_), SEEK_SET);
                iterator.reset(new Iterator(header, vsizes, file));
        }
        else
        {
                ByteBuffer* buffer(new ByteBuffer(header.payload));
                System::fread(buffer->data(), 1, header.payload, file_);
                iterator.reset(new Iterator(header, vsizes, buffer));
        }
        System::fseek(file_, end_of_postlist, SEEK_SET);
        return iterator;
}

void
PostlistReader::rewind()
{
        if (is_open()) std::rewind(file_);
}

void
PostlistReader::seek(size_t offset)
{
        if (is_open()) System::fseek(file_, offset, SEEK_SET);
}

size_t
PostlistReader::tell()
{
        return is_open() ? System::ftell(file_) : 0;
}

} // namespace invertedindex
} // namespace aitools

---