w_key.h

Go to the documentation of this file.

#ifndef __W_KEY_H
#define __W_KEY_H

#include <cassert>
#include <cstring>
#include <string>
#include <ostream>
#include <iostream> // for cout
#include <cstdint>
#include "w_endian.h"

class w_keystr_t_test;
class cvec_t;

// for now, let's use 'weird' sign bytes which is good for debugging.
// later, just use 0, 1,.. for better compression.
const unsigned char SIGN_NEGINF = 42;

const unsigned char SIGN_REGULAR = 43;

const unsigned char SIGN_POSINF = 44;

typedef uint32_t w_keystr_len_t;

class w_keystr_t {
    friend class w_keystr_t_test;

    friend std::ostream& operator<<(std::ostream&, const w_keystr_t& v);

public:
    w_keystr_t();

    w_keystr_t(const w_keystr_t& r);

    w_keystr_t& operator=(const w_keystr_t& r);

    ~w_keystr_t();

    bool construct_regularkey(const void* nonkeystr, w_keystr_len_t length);

    bool construct_neginfkey();

    bool construct_posinfkey();

    bool construct_from_keystr(const void* keystr, w_keystr_len_t length);

    bool construct_from_keystr(const void* keystr_prefix, w_keystr_len_t prefix_length,
                               const void* keystr_suffix, w_keystr_len_t suffix_length);

    bool construct_from_keystr_poormkey_16(
            const void* keystr_prefix, w_keystr_len_t prefix_length,
            w_keystr_len_t total_suffix_length, uint16_t poormkey,
            const void* keystr_suffix);
    // add 32 version if needed

    bool construct_from_vec(const cvec_t& vect);

    bool copy_from_vec(const cvec_t& vect);

    bool is_constructed() const;

    bool is_neginf() const;

    bool is_posinf() const;

    bool is_regular() const;

    w_keystr_len_t common_leading_bytes(const w_keystr_t& r) const;

    w_keystr_len_t common_leading_bytes(const unsigned char* str, w_keystr_len_t len) const;

    static w_keystr_len_t common_leading_bytes(const unsigned char* str1, w_keystr_len_t len1,
                                               const unsigned char* str2, w_keystr_len_t len2);

    static int compare_bin_str(const void* str1, int len1, const void* str2, int len2);

    int compare(const w_keystr_t& r) const;

    int compare_keystr(const void* keystr, w_keystr_len_t length) const;

    int compare_nonkeystr(const void* nonkeystr, w_keystr_len_t length) const;

    inline bool operator==(const w_keystr_t& r) const;

    inline bool operator!=(const w_keystr_t& r) const;

    inline bool operator<(const w_keystr_t& r) const;

    inline bool operator>(const w_keystr_t& r) const;

    inline bool operator<=(const w_keystr_t& r) const;

    inline bool operator>=(const w_keystr_t& r) const;

    void serialize_as_nonkeystr(void* buffer) const;

    std::basic_string<unsigned char> serialize_as_nonkeystr() const;

    w_keystr_len_t get_length_as_nonkeystr() const;

    void serialize_as_keystr(void* buffer) const;

    const void* buffer_as_keystr() const;

    w_keystr_len_t get_length_as_keystr() const;

    void clear();

private:
    unsigned char* _data;

    uint32_t _strlen;

    uint32_t _memlen;

    void _assure(w_keystr_len_t required_len);
};

inline void w_keystr_t::_assure(w_keystr_len_t required_len) {
    if (_memlen >= required_len) {
        return;
    }
    if (_data != nullptr) {
        delete[] _data;
    }
    _data = new unsigned char[required_len];
    if (_data != nullptr) {
        _memlen = required_len;
    } else {
        _memlen = 0;
    }
}

inline w_keystr_t::w_keystr_t() : _data(nullptr),
                                  _strlen(0),
                                  _memlen(0) {}

inline w_keystr_t::w_keystr_t(const w_keystr_t& r) : _data(nullptr),
                                                     _strlen(r._strlen),
                                                     _memlen(0) {
    assert (r._strlen == 0 || r.is_neginf() || r.is_regular() || r.is_posinf());
    if (r._data != nullptr) {
        _assure(_strlen);
        if (_data != nullptr) {
            ::memcpy(_data, r._data, _strlen);
        }
    }
}

inline w_keystr_t& w_keystr_t::operator=(const w_keystr_t& r) {
    assert (r._strlen == 0 || r.is_neginf() || r.is_regular() || r.is_posinf());
    _strlen = r._strlen;
    if (r._data != nullptr) {
        _assure(_strlen);
        if (_data != nullptr) {
            ::memcpy(_data, r._data, _strlen);
        }
    }
    return *this;
}

inline bool w_keystr_t::construct_regularkey(const void* nonkeystr, w_keystr_len_t length) {
    assert (nonkeystr != nullptr);
    _strlen = length + 1;
    _assure(_strlen);
    if (_data == nullptr) {
        return false;
    }
    _data[0] = SIGN_REGULAR;
    ::memcpy(_data + 1, nonkeystr, length);
    return true;
}

inline bool w_keystr_t::construct_neginfkey() {
    _strlen = 1;
    _assure(_strlen);
    if (_data == nullptr) {
        return false;
    }
    _data[0] = SIGN_NEGINF;
    return true;
}

inline bool w_keystr_t::construct_posinfkey() {
    _strlen = 1;
    _assure(_strlen);
    if (_data == nullptr) {
        return false;
    }
    _data[0] = SIGN_POSINF;
    return true;
}

// used only for asserts
inline bool _valid_signbyte(const void* keystr) {
    return ((const unsigned char*)keystr)[0] == SIGN_NEGINF  // *
           || ((const unsigned char*)keystr)[0] == SIGN_REGULAR // +
           || ((const unsigned char*)keystr)[0] == SIGN_POSINF; // ,
}

inline bool w_keystr_t::construct_from_keystr(const void* keystr, w_keystr_len_t length) {
    assert (length == 0 || keystr != nullptr);
    assert (length == 0 || _valid_signbyte(keystr));
    _strlen = length;
    _assure(_strlen);
    if (_data == nullptr) {
        return false;
    }
    ::memcpy(_data, keystr, length);
    return true;
}

inline bool w_keystr_t::construct_from_keystr(const void* keystr_prefix, w_keystr_len_t prefix_length,
                                              const void* keystr_suffix, w_keystr_len_t suffix_length) {
    assert (keystr_prefix != nullptr);
    assert ((prefix_length == 0 && _valid_signbyte(keystr_suffix))
            || _valid_signbyte(keystr_prefix));
    assert (keystr_suffix != nullptr);
    _strlen = prefix_length + suffix_length;
    _assure(_strlen);
    if (_data == nullptr) {
        return false;
    }
    ::memcpy(_data, keystr_prefix, prefix_length);
    ::memcpy(_data + prefix_length, keystr_suffix, suffix_length);
    return true;
}

inline bool w_keystr_t::construct_from_keystr_poormkey_16(
        const void* keystr_prefix, w_keystr_len_t prefix_length,
        w_keystr_len_t total_suffix_length, uint16_t poormkey,
        const void* keystr_suffix) {
    assert (keystr_prefix != nullptr);
    _strlen = prefix_length + total_suffix_length;
    _assure(_strlen);
    if (_data == nullptr) {
        return false;
    }
    ::memcpy(_data, keystr_prefix, prefix_length);
    if (total_suffix_length > 0) {
        if (total_suffix_length < sizeof(poormkey)) {
            uint16_t tmp;
            serialize16_be(&tmp, poormkey);
            _data[prefix_length] = *reinterpret_cast<unsigned char*>(&tmp);
            assert (reinterpret_cast<unsigned char*>(&tmp)[1] == 0);
        } else {
            serialize16_be(_data + prefix_length, poormkey);
            if (total_suffix_length > sizeof(poormkey)) {
                assert (keystr_suffix != nullptr);
                ::memcpy(_data + prefix_length + sizeof(poormkey), keystr_suffix,
                         total_suffix_length - sizeof(poormkey));
            }
        }
    }
    assert (_valid_signbyte(_data));
    return true;
}

inline w_keystr_t::~w_keystr_t() {
    clear();
}

inline bool w_keystr_t::is_constructed() const {
    return _data != nullptr;
}

inline int w_keystr_t::compare_bin_str(const void* str1, int len1, const void* str2, int len2) {
    int d = ::memcmp(str1, str2, (len1 <= len2 ? len1 : len2));
    // if strings are same, compare the length
    if (d == 0) {
        d = (int)len1 - (int)len2;
    }
    return d;
}

inline int w_keystr_t::compare(const w_keystr_t& r) const {
    return compare_keystr(r._data, r._strlen);
}

inline w_keystr_len_t w_keystr_t::common_leading_bytes(const w_keystr_t& r) const {
    assert (_data != nullptr);
    assert (r._data != nullptr);
    assert (_valid_signbyte(_data));
    assert (_valid_signbyte(r._data));
    return common_leading_bytes(_data, _strlen, r._data, r._strlen);
}

inline w_keystr_len_t w_keystr_t::common_leading_bytes(const unsigned char* str, w_keystr_len_t len) const {
    assert (_data != nullptr);
    assert (str != nullptr);
    assert (_valid_signbyte(_data));
    assert (_valid_signbyte(str));
    return common_leading_bytes(_data, _strlen, str, len);
}

inline w_keystr_len_t w_keystr_t::common_leading_bytes(const unsigned char* str1, w_keystr_len_t len1,
                                                       const unsigned char* str2, w_keystr_len_t len2) {
    assert (str1 != nullptr);
    assert (str2 != nullptr);
    w_keystr_len_t cmp_len = (len1 <= len2) ? len1 : len2;
    for (w_keystr_len_t i = 0; i < cmp_len; ++i) {
        if (str1[i] != str2[i]) {
            return i;
        }
    }
    return cmp_len;
}

inline int w_keystr_t::compare_keystr(const void* keystr, w_keystr_len_t length) const {
    assert (_data != nullptr);
    assert (keystr != nullptr);
    assert (_valid_signbyte(keystr));
    return compare_bin_str(_data, _strlen, keystr, length);
}

inline int w_keystr_t::compare_nonkeystr(const void* nonkeystr, w_keystr_len_t length) const {
    assert (_data != nullptr);
    assert (nonkeystr != nullptr);
    if (is_neginf()) {
        return -1;
    }
    if (is_posinf()) {
        return 1;
    }
    return compare_bin_str(_data + 1, _strlen - 1, nonkeystr, length);
}

inline void w_keystr_t::clear() {
    delete[] _data; // this is okay with _data==nullptr
    _data = nullptr;
    _strlen = 0;
    _memlen = 0;
}

inline bool w_keystr_t::is_neginf() const {
    if (_strlen == 0) {
        return false;
    }
    assert (is_constructed());
    return ((const char*)_data)[0] == SIGN_NEGINF;
}

inline bool w_keystr_t::is_posinf() const {
    if (_strlen == 0) {
        return false;
    }
    assert (is_constructed());
    return ((const char*)_data)[0] == SIGN_POSINF;
}

inline bool w_keystr_t::is_regular() const {
    if (_strlen == 0) {
        return false;
    }
    assert (is_constructed());
    return ((const char*)_data)[0] == SIGN_REGULAR;
}

inline void w_keystr_t::serialize_as_nonkeystr(void* buffer) const {
    assert (buffer != nullptr);
    assert (is_constructed());
    assert (!is_neginf() && !is_posinf()); // these can't be serialized as non-key
    ::memcpy(buffer, _data + 1, _strlen - 1);
}

inline std::basic_string<unsigned char> w_keystr_t::serialize_as_nonkeystr() const {
    assert (is_constructed());
    assert (!is_neginf() && !is_posinf()); // these can't be serialized as non-key
    return std::basic_string<unsigned char>(_data + 1, _strlen - 1);
}

inline w_keystr_len_t w_keystr_t::get_length_as_nonkeystr() const {
    return _strlen - 1;
}

inline void w_keystr_t::serialize_as_keystr(void* buffer) const {
    if (_strlen == 0) {
        return;
    }
    assert (buffer != nullptr);
    assert (is_constructed());
    ::memcpy(buffer, _data, _strlen);
}

inline const void* w_keystr_t::buffer_as_keystr() const {
    return _data;
}

inline w_keystr_len_t w_keystr_t::get_length_as_keystr() const {
    return _strlen;
}

inline std::ostream& operator<<(std::ostream& o, const w_keystr_t& v) {
    if (!v.is_constructed()) {
        o << "<Not constructed>";
    } else if (v.is_neginf()) {
        o << "<Negative Infinity>";
    } else if (v.is_posinf()) {
        o << "<Positive Infinity>";
    } else {
        o << std::string(reinterpret_cast<const char*>(v._data),
                         v._strlen); // this will not show >127 correctly, but this is just a debug function
    }
    return o;
}

inline bool w_keystr_t::operator==(const w_keystr_t& r) const {
    return compare(r) == 0;
}

inline bool w_keystr_t::operator!=(const w_keystr_t& r) const {
    return compare(r) != 0;
}

inline bool w_keystr_t::operator<(const w_keystr_t& r) const {
    return compare(r) < 0;
}

inline bool w_keystr_t::operator>(const w_keystr_t& r) const {
    return compare(r) > 0;
}

inline bool w_keystr_t::operator<=(const w_keystr_t& r) const {
    return compare(r) <= 0;
}

inline bool w_keystr_t::operator>=(const w_keystr_t& r) const {
    return compare(r) >= 0;
}

#endif // __W_KEY_H