position.h

Go to the documentation of this file.

 
#pragma once
 
#include <entttree/defs.h>
 
namespace entttree {
 
struct Position {
    using symbol_t = uint8_t;
 
private:
 
    static constexpr size_t   SYMBOL_BITS = sizeof(symbol_t) * 8;
    static constexpr symbol_t HIGH_BIT    =  ((symbol_t) 1) << (SYMBOL_BITS - 1);
    static constexpr symbol_t FULL_SYMBOL = ~((symbol_t) 0);
 
    // number of locally-stored symbols. chosen so that the whole struct
    // is a multiple of 8 bytes, for alignment.
    static constexpr size_t K = 14;
 
    template <typename T, typename H>
    friend struct geom::Digest;
 
    // high order bits are at low indices.
    union {
        symbol_t  _symbols[K];  
        symbol_t* _symbol_ptr;  
    };
    uint16_t _size;  
 
    Position(size_t n);
 
    void _push_back(symbol_t s);
 
protected:
 
          symbol_t* _data();
    const symbol_t* _data() const;
 
    symbol_t operator[](size_t i) const;
 
public:
 
    Position();
    Position(const Position&  other);
    Position(      Position&& other);
    ~Position();
 
    Position& operator=(const Position&  other);
    Position& operator=(      Position&& other);
 
    std::strong_ordering operator<=>(const Position& other) const;
    bool operator==(const Position& other) const {
        return (*this <=> other) == std::strong_ordering::equal;
    }
 
    Position before() const;
 
    Position between(const Position& other) const;
 
    Position after()  const;
 
    size_t byte_count() const { return _size; }
 
    const symbol_t* bytes() const { return _data(); }
 
    static Position from_bytes(const symbol_t* data, size_t count);
};
 
} // namespace entttree
 
 
template <typename H>
struct geom::Digest<entttree::Position,H> {
    H operator()(const entttree::Position& pos) const {
        using symbol_t = entttree::Position::symbol_t;
        H nonce = geom::truncated_constant<H>(0x249707f545e427faULL, 0x5905299ebf487d2b);
        return geom::hash_bytes<H>(
            nonce,
            pos._data(),
            pos._size * sizeof(symbol_t)
        );
    }
};
 
 
template <>
struct std::hash<entttree::Position> {
    size_t operator()(const entttree::Position& pos) const;
};