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

Go to the documentation of this file.

#include "Iterator.hpp"
#include "System.hpp"

namespace aitools {
namespace invertedindex {

Iterator::Iterator()
:       vsizes_(new SizeVector),
        index_(0)
{}

Iterator::Iterator(const Header& header, FILE* page)
:       header_(header),
        vsizes_(new SizeVector),
        page_(page),
        index_(0)
{
        if (header.value_size == 0)
        {
                assert(vsizes_->size() == length());
        }
        swap();
}

Iterator::Iterator(const Header& header, ByteBuffer* buffer)
:       header_(header),
        vsizes_(new SizeVector),
        chunk_(buffer),
        index_(0)
{
        if (header.value_size == 0)
        {
                assert(vsizes_->size() == length());
        }
        chunk_.end = header_.value_count;
}

Iterator::Iterator(const Header& header, SizeVector* vsizes, FILE* page)
:       header_(header),
        vsizes_(vsizes),
        page_(page),
        index_(0)
{
        assert(vsizes_ != NULL);
        if (header.value_size == 0)
        {
                assert(vsizes_->size() == length());
        }
        swap();
}

Iterator::Iterator(const Header& header, SizeVector* vsizes, ByteBuffer* buffer)
:       header_(header),
        vsizes_(vsizes),
        chunk_(buffer),
        index_(0)
{
        assert(vsizes_ != NULL);
        if (header.value_size == 0)
        {
                assert(vsizes_->size() == length());
        }
        chunk_.end = header_.value_count;
}

Iterator::~Iterator()
{
        delete vsizes_;
}

void
Iterator::advance()
{
        chunk_.offset += size();
        if (++index_ == chunk_.end)
        {
                swap();
        }
}

uint16_t
Iterator::checksum() const
{
        return header_.checksum;
}

const Iterator::Chunk&
Iterator::chunk() const
{
        return chunk_;
}

const Iterator::Header&
Iterator::header() const
{
        return header_;
}

const Iterator::SizeVector&
Iterator::value_sizes() const
{
        return *vsizes_;
}

size_t
Iterator::length() const
{
        return header_.value_count;
}

size_t
Iterator::payload() const
{
        return header_.payload;
}

void
Iterator::rewind()
{
        index_ = 0;
        chunk_.offset = 0;
        if (is_paged())
        {
                System::fseek(page_.file, page_.offset, SEEK_SET);
                chunk_.begin = 0;
                chunk_.end = 0;
                swap();
        }
}

bool
Iterator::swap() throw (std::runtime_error)
{
        size_t remaining_value_count(header_.value_count - chunk_.end);
        if (remaining_value_count == 0) return false;

        size_t chunk_size(0);
        size_t chunk_value_count(0);
        if (header_.value_size) // indicates constant value size
        {
                chunk_value_count = max_chunk_size / header_.value_size;
                if (chunk_value_count > remaining_value_count)
                {
                        chunk_value_count = remaining_value_count;
                }
                chunk_size = chunk_value_count * header_.value_size;
        }
        else
        {
                for (unsigned i = chunk_.end; i != header_.value_count; ++i)
                {
                        if (chunk_size > max_chunk_size) break;
                        chunk_size += (*vsizes_)[i];
                        ++chunk_value_count;
                }
        }
        index_ = chunk_.end;
        chunk_.offset = 0;
        chunk_.begin = chunk_.end;
        chunk_.end += chunk_value_count;
        chunk_.buffer->resize(chunk_size);
        System::fread(chunk_.buffer->data(), 1, chunk_size, page_.file);
        return true;
}

} // namespace invertedindex
} // namespace aitools

---