block.h

Go to the documentation of this file.

#ifndef NNGN_UTILS_ALLOC_BLOCK_H
#define NNGN_UTILS_ALLOC_BLOCK_H
 
#include <cstddef>
#include <cstdlib>
#include <type_traits>
 
#include "utils/concepts.h"
#include "utils/utils.h"
 
namespace nngn {
 
template<typename H, typename T = char>
class alloc_block {
    static constexpr bool both_trivial = trivial<H> && trivial<T>;
public:
    using header_type = H;
    using value_type = T;
    struct storage {
        // Needed because types can never be deduced from nested classes.
        // http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0293r0.pdf
        using parent = alloc_block;
        header_type header = {};
        value_type data = {};
    };
    static constexpr std::size_t data_offset = [] {
        if constexpr(std::is_standard_layout_v<alloc_block::storage>)
            return offsetof(alloc_block::storage, data);
        else {
            struct S {
                alignas(header_type) char header[sizeof(header_type)];
                alignas(value_type) char data[sizeof(value_type)];
            };
            return offsetof(S, data);
        }
    }();
    // Static helpers
    static constexpr std::size_t alloc_size(std::size_t n);
    // Constructors
    static constexpr auto from_storage_ptr(void *p) { return alloc_block{p}; }
    static constexpr alloc_block from_ptr(T *p);
    alloc_block(void) noexcept = default;
    // Accessors
    constexpr storage *data(void) { return this->p; }
    constexpr const storage *data(void) const { return this->p; }
    constexpr header_type *header(void) { return &this->p->header; }
    constexpr const header_type *header(void) const { return this->p->header; }
    constexpr value_type *get(void) { return &this->p->data; }
    constexpr const value_type *get(void) const { return &this->p->data; }
    // Allocation functions
    static alloc_block alloc(void) requires both_trivial
        { return alloc_block::alloc(sizeof(alloc_block::value_type)); }
    static alloc_block alloc(std::size_t s) requires both_trivial
        { alloc_block ret; ret.realloc(s); return ret; }
    void realloc(std::size_t s) requires both_trivial { // TODO clang
        *this = alloc_block{::realloc(this->p, s + offsetof(storage, data))};
    }
    void free(void) requires both_trivial { ::free(this->p); }
private:
    explicit alloc_block(void *p_) : p{static_cast<storage*>(p_)} {}
    storage *p = nullptr;
};
 
template<typename H, typename T>
inline constexpr std::size_t alloc_block<H, T>::alloc_size(std::size_t n) {
    return alloc_block::data_offset + n * sizeof(alloc_block::value_type);
}
 
template<typename H, typename T>
inline constexpr auto alloc_block<H, T>::from_ptr(T *p) -> alloc_block {
    using S = alloc_block::storage;
    if constexpr(std::is_standard_layout_v<S>)
        return alloc_block{NNGN_CONTAINER_OF(storage, data, p)};
    else
        return alloc_block{byte_cast<char*>(p) - alloc_block::data_offset};
}
 
}
 
#endif