iffl_common.h

Go to the documentation of this file.

#pragma once


#include <type_traits>
#include <vector>
#include <tuple>
#include <algorithm>
#include <utility>
#include <atomic>
#include <cerrno>
#include <typeinfo>
#include <memory>
#include <cstring>

#if defined(__GNUC__) || defined(__clang__)
#include <experimental/memory_resource>
#define FFL_PMR std::experimental::pmr
#else
#include <memory_resource>
#define FFL_PMR std::pmr
#endif

#include <cstdio>

#if defined(__GNUC__) || defined(__clang__)
#define FFL_UNALIGNED __attribute__ ((__packed__))
#else
#if defined(_M_IX86 )
#define FFL_UNALIGNED
#else 
#define FFL_UNALIGNED __unaligned
#endif

#endif

#if defined(__GNUC__) || defined(__clang__)
//#include <x86intrin.h>
#define FFL_PLATFORM_FAIL_FAST(EC) {std::terminate();}
#else
#include <intrin.h>
#define FFL_PLATFORM_FAIL_FAST(EC) {__debugbreak();__fastfail(EC);}
#endif

#if defined(__GNUC__) || defined(__clang__)
#define FFL_ALLIGNED_ALLOC(BYTES, ALIGNMENT) malloc(BYTES)
#define FFL_ALLIGNED_FREE(PTR) free(PTR)
#else
#define FFL_ALLIGNED_ALLOC(BYTES, ALIGNMENT) _aligned_malloc(BYTES, ALIGNMENT)
#define FFL_ALLIGNED_FREE(PTR) _aligned_free(PTR)
#endif

#ifndef FFL_FAST_FAIL
#define FFL_FAST_FAIL(EC) {FFL_PLATFORM_FAIL_FAST(EC);}
#endif
#ifndef FFL_CRASH_APPLICATION
#define FFL_CRASH_APPLICATION() FFL_FAST_FAIL(ENOTRECOVERABLE)
#endif
#ifndef FFL_CODDING_ERROR_IF
#define FFL_CODDING_ERROR_IF(C) if (C) {FFL_FAST_FAIL(ENOTRECOVERABLE);} else {;}
#endif
#ifndef FFL_CODDING_ERROR_IF_NOT
#define FFL_CODDING_ERROR_IF_NOT(C) if (C) {;} else {FFL_FAST_FAIL(ENOTRECOVERABLE);}
#endif

#define FFL_FIELD_OFFSET(T, F) (((char const *)(&((T *)nullptr)->F)) - (char const *)nullptr)
#define FFL_SIZE_THROUGH_FIELD(T, F) (FFL_FIELD_OFFSET(T, F) + sizeof(((T *)nullptr)->F))
#define FFL_PADDING_OFFSET_AFTER_FIELD(T, F) FFL_SIZE_THROUGH_FIELD(T, F)
#define FFL_PADDING_BETWEEN_FIELDS_UNSAFE(T, F1, F2)(FFL_FIELD_OFFSET(T, F2) - FFL_SIZE_THROUGH_FIELD(T, F1))
#define FFL_PADDING_BETWEEN_FIELDS(T, F1, F2)([] {static_assert(FFL_FIELD_OFFSET(T, F1) <= FFL_FIELD_OFFSET(T, F2), "F1 must have lower offset in structure than F2"); }, FFL_PADDING_BETWEEN_FIELDS_UNSAFE(T, F1, F2))
//
#define FFL_FIELD_PTR_TO_OBJ_PTR(T, F, P) ((T *)((char const *)(P) - FFL_FIELD_OFFSET(T, F)))

namespace iffl {

#ifdef min 
#define FFL_SAVED_MIN_DEFINITION min
#undef min
#endif

#ifdef max 
#define FFL_SAVED_MAX_DEFINITION max
#undef max
#endif
    inline static size_t const npos = std::numeric_limits<size_t>::max();

#ifdef FFL_SAVED_MAX_DEFINITION
#define max FFL_SAVED_MAX_DEFINITION
#undef FFL_SAVED_MAX_DEFINITION
#endif

#ifdef FFL_SAVED_MIN_DEFINITION
#define min FFL_SAVED_MIN_DEFINITION
#undef FFL_SAVED_MIN_DEFINITION
#endif

template<typename T>
constexpr inline void unused_variable([[maybe_unused]] T const &) {
}
template<typename T>
constexpr inline void unused_expression_result([[maybe_unused]] T const &) {
}

    inline size_t const ptr_to_size(void const *const ptr) {
        static_assert(sizeof(void*) == sizeof(size_t),
                      "This function assumes that on this platform size of pointer equals to a size of size_t type");
        size_t const *const size_ptr = reinterpret_cast<size_t const *const>(&ptr);
        return *size_ptr;
    }

    inline void * const size_to_ptr(size_t size) {
        static_assert(sizeof(void*) == sizeof(size_t),
                      "This function assumes that on this platform size of pointer equals to a size of size_t type");
        void ** ptr_ptr = reinterpret_cast<void **>(&size);
        return *ptr_ptr;
    }
    constexpr inline size_t roundup_size_to_alignment(size_t size, size_t alignment) noexcept {
        return alignment ? ((size + alignment - 1) / alignment) *alignment : size;
    }
    template<typename T>
    constexpr inline size_t roundup_size_to_alignment(size_t size) noexcept {
        static_assert(alignof(T) > 0, "Cannot divide by 0");
        return roundup_size_to_alignment(size, alignof(T));
    }
    inline void * roundup_ptr_to_alignment(void * ptr, size_t alignment) noexcept {
        return static_cast<void *>(size_to_ptr(roundup_size_to_alignment(ptr_to_size(ptr), alignment)));
    }
    template<typename T>
    inline void * roundup_ptr_to_alignment(void *ptr) noexcept {
        static_assert(alignof(T) > 0, "Cannot divide by 0");
        return roundup_ptr_to_alignment(ptr, alignof(T));
    }
    inline void const * roundup_ptr_to_alignment(void const *ptr, size_t alignment) noexcept {
        return static_cast<void const *>(size_to_ptr(roundup_size_to_alignment(ptr_to_size(ptr), alignment)));
    }
    template<typename T>
    inline void const * roundup_ptr_to_alignment(void const *ptr) noexcept {
        static_assert(alignof(T) > 0, "Cannot divide by 0");
        return roundup_ptr_to_alignment(ptr, alignof(T));
    }
    inline void copy_data(char *to_buffer, char const *from_buffer, size_t length) noexcept {
        std::memcpy(to_buffer, from_buffer, length);
    }

    inline void move_data(char *to_buffer, char const *from_buffer, size_t length) noexcept {
        std::memmove(to_buffer, from_buffer, length);
    }
    inline void fill_buffer(char *buffer, int value, size_t length) noexcept {
        std::memset(buffer, value, length);
    }
    inline void zero_buffer(char *buffer, size_t length) noexcept {
        fill_buffer(buffer, 0, length);
    }
    inline size_t distance(void const *begin, void const *end) noexcept {
        FFL_CODDING_ERROR_IF_NOT(begin <= end);
        return (static_cast<char const *>(end) - static_cast<char const *>(begin));
    }    
    template <typename T>
    inline char *cast_to_char_ptr(T *p) noexcept {
        if constexpr (std::is_const_v<T>) {
            return const_cast<char *>(reinterpret_cast<char const *>(p));
        } else {
            return reinterpret_cast<char *>(p);
        }
    }
    template <typename T>
    inline void *cast_to_void_ptr(T *p) noexcept {
        if constexpr (std::is_const_v<T>) {
            return const_cast<void *>(reinterpret_cast<void const *>(p));
        } else {
            return reinterpret_cast<void *>(p);
        }
    }
    template <typename G>
    class scope_guard :private G {

    public:
        explicit constexpr scope_guard(G const &g)
            : G{ g } {
        }
        explicit constexpr scope_guard(G &&g)
            : G{ std::move(g) } {
        }
        constexpr scope_guard(scope_guard &&) = default;
        constexpr scope_guard &operator=(scope_guard &&) = default;
        constexpr scope_guard(scope_guard &) = delete;
        constexpr scope_guard &operator=(scope_guard &) = delete;
        ~scope_guard() noexcept {
            discharge();
        }
        void discharge() noexcept {
            if (armed_) {
                this->G::operator()();
                armed_ = false;
            }
        }
        constexpr void disarm() noexcept {
            armed_ = false;
        }
        constexpr void arm() noexcept {
            armed_ = true;
        }
        constexpr bool is_armed() const noexcept {
            return armed_;
        }
        constexpr explicit operator bool() const noexcept {
            return is_armed();
        }

    private:
        bool armed_{ true };
    };

    template <typename G>
    inline constexpr auto make_scope_guard(G &&g) {
        return scope_guard<G>{std::forward<G>(g)};
    }

    struct attach_buffer {};

    struct range {
        size_t buffer_begin{ 0 };
        size_t data_end{ 0 };
        size_t buffer_end{ 0 };
        constexpr size_t begin() const {
            return buffer_begin;
        }
        constexpr void verify() const noexcept {
            FFL_CODDING_ERROR_IF_NOT(buffer_begin <= data_end &&
                                     data_end <= buffer_end);
        }
        constexpr size_t data_size() const noexcept {
            return data_end - buffer_begin;
        }
        constexpr size_t buffer_size() const noexcept {
            return buffer_end - buffer_begin;
        }
        constexpr size_t unused_capacity() const noexcept {
            return buffer_end - data_end;
        }
        void fill_unused_capacity_data_ptr(char *data_ptr, int fill_byte) const noexcept {
            fill_buffer(data_ptr + data_size(),
                        fill_byte,
                        unused_capacity());
        }
        void zero_unused_capacity_data_ptr(char *data_ptr) const noexcept {
            fill_unused_capacity_data_ptr(data_ptr, 0);
        }
        void fill_unused_capacity_container_ptr(char *container_ptr, int fill_byte) const noexcept {
            fill_unused_capacity_data_ptr(container_ptr + buffer_begin, fill_byte);
        }
        void zero_unused_capacity_container_ptr(char *container_ptr) const noexcept {
            zero_unused_capacity_data_ptr(container_ptr + buffer_begin);
        }
        constexpr bool buffer_contains(size_t position) const noexcept {
            return buffer_begin <= position && position < buffer_end;
        }
        constexpr bool data_contains(size_t position) const noexcept {
            return buffer_begin <= position && position < data_end;
        }
    };

    template<size_t ALIGNMENT_V>
    struct range_with_alighment : public range {
        constexpr static size_t const alignment{ ALIGNMENT_V };
        constexpr size_t data_end_aligned() const noexcept {
            return roundup_size_to_alignment(data_end, ALIGNMENT_V);
        }
        constexpr size_t buffer_end_aligned() const noexcept {
            return roundup_size_to_alignment(buffer_end, ALIGNMENT_V);
        }
        constexpr size_t data_size_padded() const noexcept {
            //
            // current element size if we also add padding
            // to keep next element aligned
            //
            return data_end_aligned() - begin();
        }
        constexpr size_t required_data_padding() const noexcept {
            //
            // Size of required data padding
            //
            return data_end_aligned() - data_end;
        }
        constexpr size_t required_buffer_padding() const noexcept {
            //
            // Size of required data padding
            //
            return buffer_end_aligned() - buffer_end;
        }
        constexpr size_t buffer_size_padded() const noexcept {
            return buffer_end_aligned() - begin();
        }
    };
    template<size_t ALIGNMENT_V>
    struct offset_with_aligment {
        constexpr static size_t const alignment{ ALIGNMENT_V };
        size_t offset{ 0 };
        constexpr size_t offset_aligned() const noexcept {
            return roundup_size_to_alignment(offset, ALIGNMENT_V);
        }
        constexpr size_t padding_size() const noexcept {
            return offset_aligned() - offset;
        }
    };
    template<size_t ALIGNMENT_V>
    struct size_with_padding {
        constexpr static size_t const alignment{ ALIGNMENT_V };
        size_t size{ 0 };
        constexpr size_t size_padded() const noexcept {
            return roundup_size_to_alignment(size, ALIGNMENT_V);
        }
        constexpr size_t padding_size() const noexcept {
            return size_padded() - size;
        }
    };

    template<size_t ALIGNMENT_V>
    struct flat_forward_list_sizes {
        size_t total_capacity{ 0 };
        range_with_alighment<ALIGNMENT_V> last_element;
        constexpr size_with_padding<ALIGNMENT_V> used_capacity() const {
            return { last_element.data_end };
        }
        constexpr size_t remaining_capacity_for_insert() const {
            return total_capacity - used_capacity().size;
        }
        //
        constexpr size_t remaining_capacity_for_append() const {
            if (total_capacity <= used_capacity().size_padded()) {
                return 0;
            } else {
                return total_capacity - used_capacity().size_padded();
            }
        }
    };

    struct zero_then_variadic_args_t {
    };

    struct one_then_variadic_args_t {
    };

    template<class T1,
        class T2,
        bool = std::is_empty_v<T1> && !std::is_final_v<T1>>
        class compressed_pair final : private T1 {
        public:

            template<class... P>
            constexpr explicit compressed_pair(zero_then_variadic_args_t,
                                               P&&... p)
                : T1()
                , v2_(std::forward<P>(p)...) {
            }
            template<class P1,
                class... P2>
                constexpr compressed_pair(one_then_variadic_args_t,
                                          P1&& p1,
                                          P2&&... p2)
                : T1(std::forward<P1>(p1))
                , v2_(std::forward<P2>(p2)...) {// construct from forwarded values
            }
            constexpr T1& get_first() noexcept {
                return (*this);
            }
            constexpr T1 const & get_first() const noexcept {
                return (*this);
            }
            constexpr T2& get_second() noexcept {
                return (v2_);
            }
            constexpr T2 const & get_second() const noexcept {
                return (v2_);
            }

        private:
            T2 v2_;
    };

    template<class T1,
        class T2>
        class compressed_pair<T1, T2, false> final {
        public:

            template<class... P>
            constexpr explicit compressed_pair(zero_then_variadic_args_t,
                                               P&&... p)
                : v1_()
                , v2_(std::forward<P>(p)...) {// construct from forwarded values
            }

            template<class P1,
                class... P2>
                constexpr compressed_pair(one_then_variadic_args_t,
                                          P1&& p1,
                                          P2&&... p2)
                : v1_(std::forward<P1>(p1))
                , v2_(std::forward<P2>(p2)...) {
            }
            constexpr T1& get_first() noexcept {
                return (v1_);
            }
            constexpr T1 const & get_first() const noexcept {
                return (v1_);
            }
            constexpr T2& get_second() noexcept {
                return (v2_);
            }
            constexpr T2 const & get_second() const noexcept {
                return (v2_);
            }

        private:
            T1 v1_;
            T2 v2_;
    };
    template <typename T = char>
    struct buffer_t {
        //
        // Buffer pointer can be const and non-const buffer
        //
        static_assert(std::is_same_v<T, char> || std::is_same_v<T, char const>, 
                      "buffer pointer can be char * or char const *");
        inline static bool const is_const{ std::is_same_v<T, char const> };
        buffer_t() = default;
        buffer_t(buffer_t const &) = default;
        buffer_t &operator= (buffer_t const &) = default;
        template<typename V,
                 typename = std::enable_if<std::is_assignable_v<T*, V*>>>
        buffer_t(buffer_t<V> const &buff) {
            begin = buff.begin;
            last = buff.last;
            end = buff.end;
        }
        template<typename V,
                 typename = std::enable_if<std::is_assignable_v<T*, V*>>>
        buffer_t & operator= (buffer_t<V> const &buff) {
            begin = buff.begin;
            last = buff.last;
            end = buff.end;
            return *this;
        }
        buffer_t(T *begin, T *last, T *end) noexcept
        :   begin{ begin }
        ,   last{ last }
        ,   end{ end } {

            validate();
        }
        buffer_t(T *begin, size_t *last_offset, T *end_offset) noexcept
            : begin{ begin }
            , last{ begin + last_offset }
            , end{ begin + end_offset } {

            validate();
        }
        using value_type = T;
        using pointer_type = T *;
        using refernce_type = T & ;
        using size_type = size_t;
        pointer_type begin{ nullptr };
        pointer_type last{ nullptr };
        pointer_type end{ nullptr };
        constexpr void set_begin(pointer_type new_begin) noexcept {
            size_type tmp_last_offset = last_offset();
            size_type tmp_size = size();
            begin = new_begin;
            set_size_unsafe(tmp_size);
            set_last_offset_unsafe(tmp_last_offset);
        }
        constexpr size_type size() const noexcept {
            return end ? end - begin
                       : 0;
        }
        constexpr void set_size_unsafe(size_type size) noexcept {
            end = begin + size;
        }
        constexpr void set_size(size_type size) noexcept {
            set_size_unsafe(size);
            validate();
        }
        constexpr size_type last_offset() const noexcept {
            return last ? last - begin
                         : iffl::npos;
        }
        constexpr void set_last_offset_unsafe(size_type offset) noexcept {
            last = (iffl::npos == offset ? nullptr
                                         : begin + offset);
        }
        constexpr void set_last_offset(size_type offset) noexcept {
            set_last_offset_unsafe(offset);
            validate();
        }
        constexpr void validate() const noexcept {
            //
            // empty() calls this method so we cannot call it here
            //
            if (nullptr == last) {
                FFL_CODDING_ERROR_IF_NOT(begin <= end);
            } else {
                FFL_CODDING_ERROR_IF_NOT(begin <= last && last <= end);
            }
        }
        constexpr void clear() noexcept {
            begin = nullptr;
            last = nullptr;
            end = nullptr;
        }
        constexpr void forget_last() noexcept {
            last = nullptr;
        }
        constexpr explicit operator bool() const noexcept {
            return begin != nullptr;
        }
    };
    using buffer_ref = buffer_t<char>;
    using buffer_view = buffer_t<char const>;

} // namespace iffl