/home/palakars/workspace-inprogress/code-in-progress/aitools3/aitools3-aq-invertedindex-cpp/src/value/StringString.cpp

Go to the documentation of this file.

#include "StringString.hpp"
#include <iostream>
#include <cassert>
#include <cstring>

namespace aitools {
namespace invertedindex {

const std::string
StringString::classname("StringString");

StringString::StringString()
:       len_(0)
{}

StringString::StringString
(const std::string& e1, const std::string& e2)
:       e1_(e1),
        e2_(e2),
        len_(0)
{}

StringString::StringString(const StringString& pair)
:   e1_(pair.e1_),
    e2_(pair.e2_),
    len_(0)
{}

StringString::~StringString()
{}

void
StringString::clear()
{
        e1_.clear();
        e2_.clear();
}

bool
StringString::operator==(const StringString& pair) const
{
        return e1_ == pair.e1_ && e2_ == pair.e2_;
}

bool
StringString::operator!=(const StringString& pair) const
{
        return !(*this == pair);
}

bool
StringString::operator>(const StringString& pair) const
{
        return score() > pair.score();
}

bool
StringString::operator<(const StringString& pair) const
{
        return score() < pair.score();
}

void
StringString::parse(std::istream& is)
{
    is >> e1_ >> e2_;
}

void
StringString::print(std::ostream& os) const
{
    os << e1_ << ' ' << e2_;
}

double
StringString::score() const
{
    return e1_.size();
}

std::string&
StringString::e1()
{
    return e1_;
}

const std::string&
StringString::e1() const
{
    return e1_;
}

std::string&
StringString::e2()
{
    return e2_;
}

const std::string&
StringString::e2() const
{
    return e2_;
}

void
StringString::to_bytes(ByteBuffer& buffer) const
{
        size_t offset(0);
        string_size length(e1_.size());
        buffer.resize(sizeof_string_size + e1_.size() + e2_.size());
        std::memcpy(buffer.data(), &length, sizeof_string_size);
        offset += sizeof_string_size;
        std::memcpy(buffer.data() + offset, e1_.data(), e1_.size());
        offset += length;
        std::memcpy(buffer.data() + offset, e2_.data(), e2_.size());
}

void
StringString::wrap(const char* data, size_t size)
{
        assert(data != NULL);
        assert(size > sizeof_string_size);
        std::memcpy(&len_, data, sizeof_string_size);
        e1_.assign(data + sizeof_string_size, len_);
        e2_.assign(data + sizeof_string_size + len_,
                           size - sizeof_string_size - len_);
}

void
StringString::wrap(const ByteBuffer& buffer)
{
        Value::wrap(buffer);
}

} // namespace invertedindex
} // namespace aitools

---