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

Go to the documentation of this file.

/* Copyright (C) 2010 webis.de
 * All rights reserved.
 */
#ifndef AITOOLS_INVERTEDINDEX_PAIR_STRING_HPP
#define AITOOLS_INVERTEDINDEX_PAIR_STRING_HPP

#include "Value.hpp"
#include <iostream>
#include <cassert>
#include <cstring>
#include <iomanip>

namespace aitools {
namespace invertedindex {

template <typename T>
class PairString : public Value
{

public: // nested types

        typedef T element_type;

public: // class data

        static const std::string classname;

        static const size_t sizeof_T = sizeof(T);

public: // c'tor / d'tor

        PairString();

        PairString(T e1, const std::string& e2);

        PairString(const PairString<T>& pair);

        virtual ~PairString();

public: // member

        void clear();

        double score() const;

        bool operator==(const PairString<T>& pair) const;

        bool operator!=(const PairString<T>& pair) const;

        bool operator>(const PairString<T>& pair) const;

        bool operator<(const PairString<T>& pair) const;

        void parse(std::istream& is);

        T& e1();

        const T& e1() const;

        std::string& e2();

        const std::string& e2() const;

        void print(std::ostream& os) const;

        void to_bytes(ByteBuffer& buffer) const;

        void wrap(const char* data, size_t size);

        void wrap(const ByteBuffer& buffer);

private: // data

        T           e1_;
        std::string e2_;

};

// IMPLEMENTATION

template <typename T>
const std::string
PairString<T>::classname
("PairString<" + Converter::nameof<T>() + ">");

template <typename T>
PairString<T>::PairString()
:   e1_(0)
{}

template <typename T>
PairString<T>::PairString(T e1, const std::string& e2)
:   e1_(e1),
        e2_(e2)
{}

template <typename T>
PairString<T>::PairString(const PairString<T>& pair)
:   e1_(pair.e1_),
        e2_(pair.e2_)
{}

template <typename T>
PairString<T>::~PairString()
{}

template <typename T>
void
PairString<T>::clear()
{
        e1_ = 0;
        e2_.clear();
}

template <typename T>
double
PairString<T>::score() const
{
        return e1_;
}

template <typename T>
bool
PairString<T>::operator==(const PairString<T>& pair) const
{
        return e1_ == pair.e1_ && e2_ == pair.e2_;
}

template <typename T>
bool
PairString<T>::operator!=(const PairString<T>& pair) const
{
        return !(*this == pair);
}

template <typename T>
bool
PairString<T>::operator>(const PairString<T>& pair) const
{
        return score() > pair.score();
}

template <typename T>
bool
PairString<T>::operator<(const PairString<T>& pair) const
{
        return score() < pair.score();
}

template <typename T>
void
PairString<T>::parse(std::istream& is)
{
        // force parsing as integer instead of a single character
        if (sizeof_T == sizeof_int8_t) is >> tmp_int, e1_ = tmp_int;
        else is >> e1_;
        is >> e2_;
}

template <typename T>
T&
PairString<T>::e1()
{
        return e1_;
}

template <typename T>
const T&
PairString<T>::e1() const
{
        return e1_;
}

template <typename T>
std::string&
PairString<T>::e2()
{
        return e2_;
}

template <typename T>
const std::string&
PairString<T>::e2() const
{
        return e2_;
}

template <typename T>
void
PairString<T>::print(std::ostream& os) const
{
        // force printing as integer instead of a not printable character
        if (sizeof_T == sizeof_int8_t) os << (int) e1_;
        else os << e1_;
        os << ' ' << e2_;
}

template <typename T>
void
PairString<T>::to_bytes(ByteBuffer& buffer) const
{
        buffer.resize(sizeof_T + e2_.size());
        std::memcpy(buffer.data(), &e1_, sizeof_T);
        std::memcpy(buffer.data() + sizeof_T, e2_.data(), e2_.size());
}

template <typename T>
void
PairString<T>::wrap(const char* data, size_t size)
{
        assert(data != NULL);
        assert(size > sizeof_T);
        std::memcpy(&e1_, data, sizeof_T);
        e2_.assign(data + sizeof_T, size - sizeof_T);
}

template <typename T>
void
PairString<T>::wrap(const ByteBuffer& buffer)
{
        Value::wrap(buffer);
}

} // namespace invertedindex
} // namespace aitools

#endif // AITOOLS_INVERTEDINDEX_PAIR_STRING_HPP

---