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

Go to the documentation of this file.

#include "PostlistBuilder.hpp"
#include "System.hpp"
#include <cstring>

namespace aitools {
namespace invertedindex {

PostlistBuilder::PostlistBuilder()
:       vsizes_(new SizeVector),
        memory_(0),
        page_(NULL)
{}

PostlistBuilder::~PostlistBuilder()
{
        delete vsizes_;
        if (has_page_file_())
        {
                std::fclose(page_);
        }
}

void
PostlistBuilder::append(const ByteBuffer& value) throw (std::runtime_error)
{
        if (has_page_file_())
        {
                System::fwrite(value.data(), 1, value.size(), page_);
        }
        else
        {
                memory_ += value.size();
                values_.push_back(value);
                if (memory_ > Iterator::max_chunk_size)
                {
                        swap_out_values_();
                }
        }
        if (header_.value_count == 0)
        {
                header_.value_size = value.size();
        }
        else if (header_.value_size != value.size())
        {
                header_.value_size = 0;
        }
        vsizes_->push_back(value.size());
        header_.payload += value.size();
        ++header_.value_count;
}

Iterator::SharedPointer
PostlistBuilder::build()
{
        // If value size is constant drop size information
        if (header_.value_size != 0)
        {
                vsizes_->clear();
        }

        Iterator::SharedPointer iterator;
        if (has_page_file_())
        {
                std::rewind(page_);
                iterator.reset(new Iterator(header_, vsizes_, page_));
                vsizes_ = new SizeVector;
                page_ = NULL; // Iterator is the owner now
        }
        else // Copy all values into one buffer
        {
                size_t offset(0);
                ByteBuffer* buffer(new ByteBuffer(header_.payload));
                ValueVector::const_iterator end(values_.end());
                for (ValueVector::const_iterator it(values_.begin()); it != end; ++it)
                {
                        std::memcpy(buffer->data() + offset, it->data(), it->size());
                        offset += it->size();
                }
                iterator.reset(new Iterator(header_, vsizes_, buffer));
                vsizes_ = new SizeVector;
        }
        clear();
        return iterator;
}

void
PostlistBuilder::clear()
{
        memory_ = 0;
        values_.clear();
        vsizes_->clear();
        header_ = Header();
        if (has_page_file_())
        {
                std::fclose(page_);
                page_ = NULL;
        }
}

bool
PostlistBuilder::empty() const
{
        return header_.value_count == 0;
}

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

void
PostlistBuilder::set_checksum(uint16_t checksum)
{
        header_.checksum = checksum;
}

void
PostlistBuilder::swap_out_values_() throw (std::runtime_error)
{
        page_ = System::tmpfile();
        ValueVector::const_iterator end(values_.end());
        for (ValueVector::const_iterator it(values_.begin()); it != end; ++it)
        {
                System::fwrite(it->data(), 1, it->size(), page_);
        }
        values_.clear();
        memory_ = 0;
}

bool
PostlistBuilder::has_page_file_() const
{
        return page_ != NULL;
}

} // namespace invertedindex
} // namespace aitools

---