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

Go to the documentation of this file.

#include "GenericRecord.hpp"
#include <boost/algorithm/string.hpp>
#include <cstdio> // std::fread, std::fwrite

namespace aitools {
namespace invertedindex {

const size_t
GenericRecord::max_key_size(std::numeric_limits<uint16_t>::max());

const size_t
GenericRecord::max_val_size(std::numeric_limits<uint16_t>::max());

GenericRecord::GenericRecord()
:       key_size_(0),
        val_size_(0)
{}

GenericRecord::GenericRecord(const GenericRecord& record)
:       key_(record.key_),
    val_(record.val_),
    key_size_(0),
    val_size_(0)
{}

GenericRecord::GenericRecord(const std::string& key, const ByteBuffer& value)
:   key_(key),
    val_(value),
    key_size_(0),
    val_size_(0)
{}

GenericRecord::~GenericRecord()
{}

std::string&
GenericRecord::key()
{
    return key_;
}

const std::string&
GenericRecord::key() const
{
    return key_;
}

GenericRecord&
GenericRecord::operator=(const GenericRecord& record)
{
        key_ = record.key_;
        val_ = record.val_;
        return *this;
}

bool
GenericRecord::operator==(const GenericRecord& record) const
{
        return key_ == record.key_ && val_ == record.val_;
}

bool
GenericRecord::operator!=(const GenericRecord& record) const
{
        return !(*this == record);
}

ByteBuffer&
GenericRecord::value()
{
    return val_;
}

const ByteBuffer&
GenericRecord::value() const
{
    return val_;
}

bool
GenericRecord::write(FILE* file)
{
        key_size_ = key_.size();
        val_size_ = val_.size();
        if (std::fwrite(&key_size_, sizeof_key_size_t, 1, file) != 1) return false;
        if (std::fwrite(&val_size_, sizeof_val_size_t, 1, file) != 1) return false;
        if (std::fwrite(key_.data(), 1, key_size_, file) != key_size_) return false;
        if (std::fwrite(val_.data(), 1, val_size_, file) != val_size_) return false;
        return true;
}

bool
GenericRecord::read(FILE* file)
{
        key_.clear(); // needed for correct string comparison
//      val_.clear(); // needed for correct string comparison
        if (std::fread(&key_size_, sizeof_key_size_t, 1, file) != 1) return false;
        if (std::fread(&val_size_, sizeof_val_size_t, 1, file) != 1) return false;
        key_.resize(key_size_);
        val_.resize(val_size_);
        if (std::fread((void*)key_.data(), 1, key_size_, file) != key_size_)
                return false;
        if (std::fread(val_.data(), 1, val_size_, file) != val_size_) return false;
        return true;
}

size_t
GenericRecord::size() const
{
    return sizeof_key_size_t + sizeof_val_size_t + key_.size() + val_.size();
}

} // namespace invertedindex
} // namespace aitools

namespace std {

ostream&
operator<<(ostream& os, const aitools::invertedindex::GenericRecord& record)
{
        if (os)
        {
                os << "GenericRecord [ key = " << record.key()
                   << " , value = " << record.value() << " ]";
        }
        return os;
}

} // namespace std

---