util.h

Go to the documentation of this file.

#ifndef ZTH_UTIL_H
#define ZTH_UTIL_H
/*
 * Zth (libzth), a cooperative userspace multitasking library.
 * Copyright (C) 2019-2022  Jochem Rutgers
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */
 
#include <libzth/macros.h>
#include <libzth/config.h>
 
#define ZTH_STRINGIFY_(x) #x
#define ZTH_STRINGIFY(x) ZTH_STRINGIFY_(x)
 
#ifndef likely
#       ifdef __GNUC__
#               define likely(expr) __builtin_expect(!!(expr), 1)
#       else
#               define likely(expr) (expr)
#       endif
#endif
 
#ifndef unlikely
#       ifdef __GNUC__
#               define unlikely(expr) __builtin_expect(!!(expr), 0)
#       else
#               define unlikely(expr) (expr)
#       endif
#endif
 
#include <assert.h>
#if defined(__cplusplus) && __cplusplus < 201103L && !defined(static_assert)
#       pragma GCC diagnostic ignored "-Wunused-local-typedefs"
#       define static_assert(expr, msg) typedef int static_assert_[(expr) ? 1 : -1]
#endif
 
#define ZTH_GET_MACRO_ARGN(                                                                   \
        _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, NAME, ...) \
        NAME
 
#ifndef FOREACH
#       define FOREACH_0(WHAT)             
#       define FOREACH_1(WHAT, X) WHAT(X) 
#       define FOREACH_2(WHAT, X, ...) \
                WHAT(X) FOREACH_1(WHAT, __VA_ARGS__) 
#       define FOREACH_3(WHAT, X, ...) \
                WHAT(X) FOREACH_2(WHAT, __VA_ARGS__) 
#       define FOREACH_4(WHAT, X, ...) \
                WHAT(X) FOREACH_3(WHAT, __VA_ARGS__) 
#       define FOREACH_5(WHAT, X, ...) \
                WHAT(X) FOREACH_4(WHAT, __VA_ARGS__) 
#       define FOREACH_6(WHAT, X, ...) \
                WHAT(X) FOREACH_5(WHAT, __VA_ARGS__) 
#       define FOREACH_7(WHAT, X, ...) \
                WHAT(X) FOREACH_6(WHAT, __VA_ARGS__) 
#       define FOREACH_8(WHAT, X, ...) \
                WHAT(X) FOREACH_7(WHAT, __VA_ARGS__) 
#       define FOREACH_9(WHAT, X, ...) \
                WHAT(X) FOREACH_8(WHAT, __VA_ARGS__) 
#       define FOREACH_10(WHAT, X, ...) \
                WHAT(X) FOREACH_9(WHAT, __VA_ARGS__) 
#       define FOREACH_11(WHAT, X, ...) \
                WHAT(X) FOREACH_10(WHAT, __VA_ARGS__) 
#       define FOREACH_12(WHAT, X, ...) \
                WHAT(X) FOREACH_11(WHAT, __VA_ARGS__) 
#       define FOREACH_13(WHAT, X, ...) \
                WHAT(X) FOREACH_12(WHAT, __VA_ARGS__) 
#       define FOREACH_14(WHAT, X, ...) \
                WHAT(X) FOREACH_13(WHAT, __VA_ARGS__) 
#       define FOREACH_15(WHAT, X, ...) \
                WHAT(X) FOREACH_14(WHAT, __VA_ARGS__) 
#       define FOREACH_16(WHAT, X, ...) \
                WHAT(X) FOREACH_15(WHAT, __VA_ARGS__) 
//... repeat as needed
 
#       define FOREACH(action, ...)                                                         \
                ZTH_GET_MACRO_ARGN(                                                          \
                        0, ##__VA_ARGS__, FOREACH_16, FOREACH_15, FOREACH_14, FOREACH_13,    \
                        FOREACH_12, FOREACH_11, FOREACH_10, FOREACH_9, FOREACH_8, FOREACH_7, \
                        FOREACH_6, FOREACH_5, FOREACH_4, FOREACH_3, FOREACH_2, FOREACH_1,    \
                        FOREACH_0)                                                           \
                (action, ##__VA_ARGS__)
#endif
 
#ifndef REVERSE
#       define REVERSE_0()
#       define REVERSE_1(a)        a
#       define REVERSE_2(a, ...)  REVERSE_1(__VA_ARGS__), a
#       define REVERSE_3(a, ...)  REVERSE_2(__VA_ARGS__), a
#       define REVERSE_4(a, ...)  REVERSE_3(__VA_ARGS__), a
#       define REVERSE_5(a, ...)  REVERSE_4(__VA_ARGS__), a
#       define REVERSE_6(a, ...)  REVERSE_5(__VA_ARGS__), a
#       define REVERSE_7(a, ...)  REVERSE_6(__VA_ARGS__), a
#       define REVERSE_8(a, ...)  REVERSE_7(__VA_ARGS__), a
#       define REVERSE_9(a, ...)  REVERSE_8(__VA_ARGS__), a
#       define REVERSE_10(a, ...) REVERSE_9(__VA_ARGS__), a
#       define REVERSE_11(a, ...) REVERSE_10(__VA_ARGS__), a
#       define REVERSE_12(a, ...) REVERSE_11(__VA_ARGS__), a
#       define REVERSE_13(a, ...) REVERSE_12(__VA_ARGS__), a
#       define REVERSE_14(a, ...) REVERSE_13(__VA_ARGS__), a
#       define REVERSE_15(a, ...) REVERSE_14(__VA_ARGS__), a
#       define REVERSE_16(a, ...) REVERSE_15(__VA_ARGS__), a
#       define REVERSE(...)                                                                 \
                ZTH_GET_MACRO_ARGN(                                                          \
                        0, ##__VA_ARGS__, REVERSE_16, REVERSE_15, REVERSE_14, REVERSE_13,    \
                        REVERSE_12, REVERSE_11, REVERSE_10, REVERSE_9, REVERSE_8, REVERSE_7, \
                        REVERSE_6, REVERSE_5, REVERSE_4, REVERSE_3, REVERSE_2, REVERSE_1,    \
                        REVERSE_0)                                                           \
                (__VA_ARGS__)
#endif
 
#include <stdarg.h>
 
#ifdef __cplusplus
#       include <cstdio>
#       include <cstdlib>
#       include <cstring>
#       include <limits>
#       include <memory>
#       include <string>
#       include <vector>
 
#       if __cplusplus >= 201103L
#               include <cinttypes>
#       else
#               include <inttypes.h>
#       endif
 
#       ifdef ZTH_HAVE_PTHREAD
#               include <pthread.h>
#       endif
 
#       ifdef ZTH_OS_WINDOWS
#               include <process.h>
#       else
#               include <sys/types.h>
#               include <unistd.h>
#       endif
 
EXTERN_C ZTH_EXPORT __attribute__((format(ZTH_ATTR_PRINTF, 1, 0))) void
zth_logv(char const* fmt, va_list arg);
 
#       ifdef __cplusplus
#               define ZTH_DBG_PREFIX " > "
 
#               define zth_dbg(group, fmt, a...)                                             \
                        do {                                                                  \
                                if(::zth::Config::SupportDebugPrint                           \
                                   && ::zth::Config::Print_##group > 0                        \
                                   && zth_config(EnableDebugPrint)) {                         \
                                        if(::zth::Config::EnableColorLog)                     \
                                                ::zth::log_color(                             \
                                                        ::zth::Config::Print_##group,         \
                                                        ZTH_DBG_PREFIX                        \
                                                        "zth::" ZTH_STRINGIFY(group) ": " fmt \
                                                                                     "\n",    \
                                                        ##a);                                 \
                                        else                                                  \
                                                ::zth::log(                                   \
                                                        ZTH_DBG_PREFIX                        \
                                                        "zth::" ZTH_STRINGIFY(group) ": " fmt \
                                                                                     "\n",    \
                                                        ##a);                                 \
                                }                                                             \
                        } while(0)
 
#               ifndef NDEBUG
#                       define zth_assert(expr)                                             \
                                do {                                                         \
                                        if(unlikely(::zth::Config::EnableAssert && !(expr))) \
                                                ::zth::assert_handler(                       \
                                                        __FILE__, __LINE__,                  \
                                                        ::zth::Config::EnableFullAssert      \
                                                                ? ZTH_STRINGIFY(expr)        \
                                                                : nullptr);                  \
                                } while(false)
#               else
#                       define zth_assert(...) \
                                do {            \
                                } while(0)
#               endif
#       endif
 
#       ifndef ZTH_CLASS_NOCOPY
#               if __cplusplus >= 201103L
#                       define ZTH_CLASS_NOCOPY(Class)                                                      \
                        public:                                                                              \
                                Class(Class const&) = delete;                                                \
                                Class(Class&&) =                                                             \
                                        delete; /* NOLINT(misc-macro-parentheses,bugprone-macro-parentheses) \
                                                 */                                                          \
                                Class& operator=(Class const&) noexcept = delete;                            \
                                Class& operator=(Class&&) noexcept =                                         \
                                        delete; /* NOLINT(misc-macro-parentheses,bugprone-macro-parentheses) \
                                                 */                                                          \
                        private:
#               else
#                       define ZTH_CLASS_NOCOPY(Class) \
                        private:                        \
                                Class(Class const&);    \
                                Class& operator=(Class const&);
#               endif
#       endif
 
#       include <libzth/zmq.h>
 
namespace zth {
 
ZTH_EXPORT char const* banner() noexcept;
 
ZTH_EXPORT __attribute__((format(ZTH_ATTR_PRINTF, 1, 2), noreturn)) void
abort(char const* fmt, ...) noexcept;
 
ZTH_EXPORT __attribute__((format(ZTH_ATTR_PRINTF, 1, 0), noreturn)) void
abortv(char const* fmt, va_list args) noexcept;
 
ZTH_EXPORT __attribute__((noreturn)) void
assert_handler(char const* file, int line, char const* expr);
 
ZTH_EXPORT bool log_supports_ansi_colors() noexcept;
 
ZTH_EXPORT __attribute__((format(ZTH_ATTR_PRINTF, 2, 0))) void
log_colorv(int color, char const* fmt, va_list args);
 
ZTH_EXPORT __attribute__((format(ZTH_ATTR_PRINTF, 2, 3))) inline void
log_color(int color, char const* fmt, ...)
{
        va_list args;
        va_start(args, fmt);
        log_colorv(color, fmt, args);
        va_end(args);
}
 
ZTH_EXPORT __attribute__((format(ZTH_ATTR_PRINTF, 1, 0))) inline void
logv(char const* fmt, va_list arg)
{
        ::zth_logv(fmt, arg);
}
 
ZTH_EXPORT __attribute__((format(ZTH_ATTR_PRINTF, 1, 2))) inline void log(char const* fmt, ...)
{
        va_list args;
        va_start(args, fmt);
        logv(fmt, args);
        va_end(args);
}
 
typedef std::basic_string<char, std::char_traits<char>, Config::Allocator<char>::type> string;
 
class cow_string {
public:
        cow_string()
                : m_cstr()
        {}
 
        // cppcheck-suppress noExplicitConstructor
        cow_string(char const* s)
                : m_cstr(s)
        {}
 
        // cppcheck-suppress noExplicitConstructor
        cow_string(string const& s)
                : m_cstr()
                , m_str(s)
        {}
 
        cow_string(cow_string const& s)
        {
                *this = s;
        }
 
        cow_string& operator=(cow_string const& s)
        {
                m_cstr = s.m_cstr;
                m_str = s.m_str;
                return *this;
        }
 
        cow_string& operator=(char const* s)
        {
                m_cstr = s;
                m_str.clear();
                return *this;
        }
 
        cow_string& operator=(string const& s)
        {
                m_cstr = nullptr;
                m_str = s;
                return *this;
        }
 
#       if __cplusplus >= 201103L
        cow_string(cow_string&& s) = default;
        cow_string& operator=(cow_string&& s) = default;
 
        // cppcheck-suppress noExplicitConstructor
        cow_string(string&& s)
                : m_cstr()
                , m_str(std::move(s))
        {}
 
        cow_string& operator=(string&& s)
        {
                m_cstr = nullptr;
                m_str = std::move(s);
                return *this;
        }
 
        string str() &&
        {
                // cppcheck-suppress returnStdMoveLocal
                return std::move(local());
        }
#       endif
 
        string const& str() const LREF_QUALIFIED
        {
                return local();
        }
 
        char const* c_str() const
        {
                return m_cstr ? m_cstr : m_str.c_str();
        }
 
        operator string const &() const
        {
                return str();
        }
 
        char const& at(size_t pos) const
        {
                return str().at(pos);
        }
 
        char operator[](size_t pos) const
        {
                return m_cstr ? m_cstr[pos] : str()[pos];
        }
 
        char& operator[](size_t pos)
        {
                return local()[pos];
        }
 
        char const* data() const
        {
                return c_str();
        }
 
        bool empty() const noexcept
        {
                return m_cstr ? *m_cstr == 0 : m_str.empty();
        }
 
        size_t size() const noexcept
        {
                return str().size();
        }
 
        size_t length() const noexcept
        {
                return str().length();
        }
 
        void clear() noexcept
        {
                m_cstr = nullptr;
                m_str.clear();
        }
 
        bool isConst() const noexcept
        {
                return m_cstr != nullptr;
        }
 
        bool isLocal() const noexcept
        {
                return m_cstr == nullptr;
        }
 
protected:
        string const& local() const
        {
                if(unlikely(m_cstr)) {
                        m_str = m_cstr;
                        m_cstr = nullptr;
                }
                return m_str;
        }
 
        string& local()
        {
                const_cast<cow_string const*>(this)->local();
                return m_str;
        }
 
private:
        mutable char const* m_cstr;
        mutable string m_str;
};
 
__attribute__((format(ZTH_ATTR_PRINTF, 1, 0))) string formatv(char const* fmt, va_list args);
 
__attribute__((format(ZTH_ATTR_PRINTF, 1, 2))) inline string format(char const* fmt, ...)
{
        va_list args;
        va_start(args, fmt);
        string res = formatv(fmt, args);
        va_end(args);
        return res;
}
 
template <typename T>
inline cow_string str(T value)
{
        return cow_string(value);
}
 
template <>
inline cow_string str<char>(char value)
{
        return format("%c", value);
}
 
template <>
inline cow_string str<signed char>(signed char value)
{
        return format("%hhd", value);
}
 
template <>
inline cow_string str<unsigned char>(unsigned char value)
{
        return format("%hhu", value);
}
 
template <>
inline cow_string str<short>(short value)
{
        return format("%hd", value);
}
 
template <>
inline cow_string str<unsigned short>(unsigned short value)
{
        return format("%hu", value);
}
 
template <>
inline cow_string str<int>(int value)
{
        return format("%d", value);
}
 
template <>
inline cow_string str<unsigned int>(unsigned int value)
{
        return format("%u", value);
}
 
template <>
inline cow_string str<long>(long value)
{
        return format("%ld", value);
}
 
template <>
inline cow_string str<unsigned long>(unsigned long value)
{
        return format("%lu", value);
}
 
template <>
inline cow_string str<long long>(long long value)
{
        return format("%lld", value);
}
 
template <>
inline cow_string str<unsigned long long>(unsigned long long value)
{
        return format("%llu", value);
}
 
template <>
inline cow_string str<float>(float value)
{
        return format("%g", (double)value);
}
 
template <>
inline cow_string str<double>(double value)
{
        return format("%g", value);
}
 
template <>
inline cow_string str<long double>(long double value)
{
        return format("%Lg", value);
}
 
#       if __cplusplus >= 201103L
template <>
inline cow_string str<string&&>(string&& value)
{
        return cow_string(std::move(value));
}
#       endif
 
inline string err(int e)
{
#       ifdef ZTH_OS_BAREMETAL
        // You are probably low on memory. Don't include all strerror strings in the binary.
        return format("error %d", e);
#       elif defined(ZTH_HAVE_LIBZMQ)
        return format("%s (error %d)", zmq_strerror(e), e);
#       elif ZTH_THREADS && !defined(ZTH_OS_WINDOWS)
        char buf[128];
#               if !defined(ZTH_OS_LINUX) || (_POSIX_C_SOURCE >= 200112L) && !defined(_GNU_SOURCE)
        // XSI-compatible
        return format("%s (error %d)", strerror_r(e, buf, sizeof(buf)) ? "Unknown error" : buf, e);
#               else
        // GNU-specific
        return format("%s (error %d)", strerror_r(e, buf, sizeof(buf)), e);
#               endif
#       else
        // Not thread-safe
        return format("%s (error %d)", strerror(e), e);
#       endif
}
 
class UniqueIDBase {
protected:
        virtual char const* id_str() const = 0;
        virtual ~UniqueIDBase() is_default
        friend cow_string str<UniqueIDBase const&>(UniqueIDBase const&);
};
 
template <>
inline cow_string str<UniqueIDBase const&>(UniqueIDBase const& value)
{
        return cow_string(value.id_str());
}
 
template <typename T, bool ThreadSafe = Config::EnableThreads>
class UniqueID : public UniqueIDBase {
#       if __cplusplus < 201103L
        ZTH_CLASS_NOCOPY(UniqueID)
#       else
public:
        UniqueID(UniqueID const&) = delete;
        UniqueID& operator=(UniqueID const&) = delete;
 
        UniqueID(UniqueID&& u) noexcept
                : m_id{}
        {
                *this = std::move(u);
        }
 
        UniqueID& operator=(UniqueID&& u) noexcept
        {
                m_id = u.m_id;
                m_name = std::move(u.m_name);
                m_id_str = std::move(u.m_id_str);
 
                u.m_id = 0;
 
                return *this;
        }
#       endif
public:
        static uint64_t getID() noexcept
        {
                return ThreadSafe ?
#       if GCC_VERSION < 40802L
                                  __sync_add_and_fetch(&m_nextId, 1)
#       else
                                  __atomic_add_fetch(&m_nextId, 1, __ATOMIC_RELAXED)
#       endif
                                  : ++m_nextId;
        }
 
        explicit UniqueID(string const& name)
                : m_id(getID())
                , m_name(name)
        {}
 
#       if __cplusplus >= 201103L
        explicit UniqueID(string&& name)
                : m_id(getID())
                , m_name(std::move(name))
        {}
#       endif
 
        explicit UniqueID(char const* name = nullptr)
                : m_id(getID())
        {
                if(name)
                        m_name = name;
        }
 
        virtual ~UniqueID() is_default
 
        void const* normptr() const noexcept
        {
                return this;
        }
 
        __attribute__((pure)) uint64_t id() const noexcept
        {
                return m_id;
        }
 
        string const& name() const noexcept
        {
                return m_name;
        }
 
        void setName(string const& name)
        {
                setName(name.c_str());
        }
 
        void setName(char const* name)
        {
                m_name = name;
                m_id_str.clear();
                changedName(this->name());
        }
 
#       if __cplusplus >= 201103L
        void setName(string&& name)
        {
                m_name = std::move(name);
                m_id_str.clear();
                changedName(this->name());
        }
#       endif
 
        virtual char const* id_str() const override
        {
                if(unlikely(m_id_str.empty())) {
                        m_id_str =
#       ifdef ZTH_OS_BAREMETAL
                                // No OS, no pid. And if newlib is used, don't try to format 64-bit
                                // ints.
                                format("%s #%u", name().empty() ? "Object" : name().c_str(),
                                       (unsigned int)id());
#       else
                                format("%s #%u:%" PRIu64,
                                       name().empty() ? "Object" : name().c_str(),
#               ifdef ZTH_OS_WINDOWS
                                       (unsigned int)_getpid(),
#               else
                                       (unsigned int)getpid(),
#               endif
                                       id());
#       endif
                        if(unlikely(m_id_str.empty()))
                                // Should not happen, but make sure the string is not empty.
                                m_id_str = "?";
                }
 
                return m_id_str.c_str();
        }
 
private:
        virtual void changedName(string const& UNUSED_PAR(name)) {}
 
private:
        uint64_t m_id;
        string m_name;
        string mutable m_id_str;
        // If allocating once every ns, it takes more than 500 years until we run out of
        // identifiers.
        static uint64_t m_nextId;
};
 
template <typename T, bool ThreadSafe>
uint64_t UniqueID<T, ThreadSafe>::m_nextId = 0;
 
template <typename T, typename WhenTIsVoid>
struct choose_type {
        typedef T type;
};
 
template <typename WhenTIsVoid>
struct choose_type<void, WhenTIsVoid> {
        typedef WhenTIsVoid type;
};
 
#       if __cplusplus >= 201103L
template <size_t...>
struct Sequence {};
#               ifndef DOXYGEN
template <size_t N, size_t... S>
struct SequenceGenerator : SequenceGenerator<N - 1, N - 1, S...> {};
 
template <size_t... S>
struct SequenceGenerator<0, S...> {
        typedef Sequence<S...> type;
};
#               endif
#       endif
#       ifdef _DEBUG
template <typename T>
class safe_ptr {
public:
        typedef safe_ptr type;
        typedef T pointer_type;
 
        // cppcheck-suppress noExplicitConstructor
        constexpr safe_ptr(pointer_type* p) noexcept
                : m_p(p)
        {}
 
        constexpr operator pointer_type*() const noexcept
        {
                return ptr();
        }
 
        constexpr operator bool() const noexcept
        {
                return ptr();
        }
 
        constexpr14 pointer_type* operator->() const noexcept
        {
                zth_assert(ptr());
                return ptr();
        }
 
        constexpr14 pointer_type& operator*() const noexcept
        {
                zth_assert(ptr());
                // cppcheck-suppress nullPointerRedundantCheck
                return *ptr();
        }
 
protected:
        constexpr pointer_type* ptr() const noexcept
        {
                return m_p;
        }
 
private:
        pointer_type* m_p;
};
#       else  // _DEBUG
 
// No checking, use use the pointer.
template <typename T>
class safe_ptr {
public:
        typedef T* type;
};
#       endif // !_DEBUG
 
template <typename T>
class Singleton {
public:
        typedef T singleton_type;
 
protected:
        constexpr14 Singleton() noexcept
        {
                // Do not enforce construction of only one Singleton, only register the first one
                // as 'the' instance.
 
                if(!m_instance)
                        m_instance = static_cast<singleton_type*>(this);
        }
 
        ~Singleton()
        {
                if(m_instance == static_cast<singleton_type*>(this))
                        m_instance = nullptr;
        }
 
public:
        __attribute__((pure)) constexpr14 static typename safe_ptr<singleton_type>::type
        instance() noexcept
        {
                return m_instance;
        }
 
private:
        static singleton_type* m_instance;
};
 
template <typename T>
typename Singleton<T>::singleton_type* Singleton<T>::m_instance = nullptr;
 
template <typename T>
class ThreadLocalSingleton {
public:
        typedef T singleton_type;
 
protected:
        __attribute__((no_sanitize_undefined)) ThreadLocalSingleton()
        {
                // Do not enforce construction of only one Singleton, only register the first one
                // as 'the' instance.
 
                if(!ZTH_TLS_GET(m_instance))
                        ZTH_TLS_SET(m_instance, static_cast<singleton_type*>(this));
        }
 
        __attribute__((no_sanitize_undefined)) ~ThreadLocalSingleton()
        {
                if(ZTH_TLS_GET(m_instance) == static_cast<singleton_type*>(this))
                        ZTH_TLS_SET(m_instance, nullptr);
        }
 
public:
        __attribute__((pure)) static typename safe_ptr<singleton_type>::type instance() noexcept
        {
                return ZTH_TLS_GET(m_instance);
        }
 
private:
        ZTH_TLS_MEMBER(singleton_type*, m_instance)
};
 
template <typename T>
ZTH_TLS_DEFINE(
        typename ThreadLocalSingleton<T>::singleton_type*, ThreadLocalSingleton<T>::m_instance,
        nullptr)
 
 
template <typename T, int8_t Prealloc = 1, typename Allocator = typename Config::Allocator<T>::type>
class small_vector {
public:
        typedef T value_type;
        typedef Allocator allocator_type;
        typedef std::vector<value_type, allocator_type> vector_type;
 
        enum { prealloc_request = Prealloc > 0 ? Prealloc : 0,
               prealloc_request_size = prealloc_request * sizeof(value_type),
               vector_size = sizeof(vector_type),
               buffer_size =
                       prealloc_request_size > vector_size ? prealloc_request_size : vector_size,
               prealloc = buffer_size / sizeof(value_type),
        };
 
        // cppcheck-suppress uninitMemberVar
        constexpr small_vector() noexcept
                : m_size()
        {
                static_assert(prealloc < std::numeric_limits<uint8_t>::max(), "");
        }
 
        ~small_vector()
        {
                if(is_small())
                        resize(0);
                else
                        vector().~vector_type();
        }
 
        value_type& operator[](size_t index) noexcept
        {
                zth_assert(index < size());
                return data()[index];
        }
 
        value_type const& operator[](size_t index) const noexcept
        {
                zth_assert(index < size());
                return data()[index];
        }
 
        value_type& front() noexcept
        {
                return (*this)[0];
        }
 
        value_type const& front() const noexcept
        {
                return (*this)[0];
        }
 
        value_type& back() noexcept
        {
                zth_assert(!empty());
                return (*this)[size() - 1u];
        }
 
        value_type const& back() const noexcept
        {
                zth_assert(!empty());
                return (*this)[size() - 1u];
        }
 
        value_type* data() noexcept
        {
                return is_small() ? array() : vector().data();
        }
 
        value_type const* data() const noexcept
        {
                return is_small() ? array() : vector().data();
        }
 
        bool empty() const noexcept
        {
                return is_small() ? m_size == 0 : vector().empty();
        }
 
        size_t size() const noexcept
        {
                return is_small() ? m_size : vector().size();
        }
 
        void reserve(size_t new_cap)
        {
                if(is_small() && new_cap <= prealloc)
                        return;
 
                if(is_small())
                        make_vector(new_cap);
 
                vector().reserve(new_cap);
        }
 
        size_t capacity() const noexcept
        {
                return is_small() ? (size_t)prealloc : vector().capacity();
        }
 
        void clear() noexcept
        {
                if(is_small())
                        resize(0);
                else
                        vector().clear();
        }
 
        void clear_and_release() noexcept
        {
                if(is_small()) {
                        resize(0);
                } else {
                        vector_type v;
                        v.swap(vector());
                }
        }
 
        void push_back(value_type const& v)
        {
                reserve(size() + 1u);
 
                if(m_size < prealloc) {
                        new(&array()[m_size]) value_type(v);
                        m_size++;
                } else
                        vector().push_back(v);
        }
 
#       if __cplusplus >= 201103L
        template <class... Args>
        void emplace_back(Args&&... args)
        {
                reserve(size() + 1u);
 
                if(m_size < prealloc) {
                        new(&array()[m_size]) value_type(std::forward<Args>(args)...);
                        m_size++;
                } else
                        vector().emplace_back(std::forward<Args>(args)...);
        }
#       endif
 
        void pop_back() noexcept
        {
                zth_assert(!empty());
                if(is_small())
                        array()[--m_size].~value_type();
                else
                        vector().pop_back();
        }
 
        void resize(size_t count, value_type const& x = value_type())
        {
                if(is_small()) {
                        while(count < m_size)
                                array()[--m_size].~value_type();
 
                        if(count <= prealloc) {
                                while(count > m_size) {
                                        new(&array()[m_size]) value_type(x);
                                        m_size++;
                                }
                        } else {
                                make_vector(count);
                                vector().resize(count, x);
                        }
                } else
                        vector().resize(count, x);
        }
 
protected:
        bool is_small() const noexcept
        {
                return m_size <= prealloc;
        }
 
        value_type* array() noexcept
        {
                zth_assert(is_small());
                return reinterpret_cast<value_type*>(m_buffer);
        }
 
        value_type const* array() const noexcept
        {
                zth_assert(is_small());
                return reinterpret_cast<value_type const*>(m_buffer);
        }
 
        vector_type& vector() noexcept
        {
                zth_assert(!is_small());
                void* buffer = m_buffer;
                return *reinterpret_cast<vector_type*>(buffer);
        }
 
        vector_type const& vector() const noexcept
        {
                zth_assert(!is_small());
                void const* buffer = m_buffer;
                return *reinterpret_cast<vector_type const*>(buffer);
        }
 
        void make_vector(size_t new_cap)
        {
                if(!is_small())
                        return;
 
                vector_type v;
                v.reserve(std::max(new_cap, (size_t)m_size));
 
                for(size_t i = 0; i < m_size; i++) {
#       if __cplusplus >= 201103L
                        v.emplace_back(std::move(array()[i]));
#       else
                        v.push_back(array()[i]);
#       endif
                        array()[i].~value_type();
                }
 
                m_size = prealloc + 1u;
                new(m_buffer) vector_type;
                vector().swap(v);
        }
 
private:
        alignas(vector_type) alignas(value_type) char m_buffer[buffer_size];
 
        uint8_t m_size;
};
 
template <size_t size>
struct smallest_uint_size {};
 
template <
        uint64_t x,
        typename size = smallest_uint_size<
                x >= 0x100000000ULL ? 8U : x >= 0x10000U ? 4U : x >= 0x100U ? 2U : 1U> >
struct smallest_uint {
        typedef uint64_t type;
};
 
template <uint64_t x>
struct smallest_uint<x, smallest_uint_size<1> > {
        typedef uint8_t type;
};
 
template <uint64_t x>
struct smallest_uint<x, smallest_uint_size<2> > {
        typedef uint16_t type;
};
 
template <uint64_t x>
struct smallest_uint<x, smallest_uint_size<4> > {
        typedef uint32_t type;
};
 
} // namespace zth
 
#endif // __cplusplus
 
#ifdef __cplusplus
EXTERN_C ZTH_EXPORT ZTH_INLINE void zth_banner()
{
        zth::banner();
}
#else
ZTH_EXPORT void zth_banner();
#endif
 
ZTH_EXPORT __attribute__((format(ZTH_ATTR_PRINTF, 1, 2), noreturn)) void
zth_abort(char const* fmt, ...);
 
#ifdef __cplusplus
EXTERN_C ZTH_EXPORT ZTH_INLINE __attribute__((format(ZTH_ATTR_PRINTF, 2, 3))) void
zth_log_color(int color, char const* fmt, ...)
{
        va_list args;
        va_start(args, fmt);
        zth::log_colorv(color, fmt, args);
        va_end(args);
}
#else
ZTH_EXPORT __attribute__((format(ZTH_ATTR_PRINTF, 2, 3))) void
zth_log_color(int color, char const* fmt, ...);
#endif
 
#ifdef __cplusplus
EXTERN_C ZTH_EXPORT ZTH_INLINE __attribute__((format(ZTH_ATTR_PRINTF, 1, 2))) void
zth_log(char const* fmt, ...)
{
        va_list args;
        va_start(args, fmt);
        zth::logv(fmt, args);
        va_end(args);
}
#else
ZTH_EXPORT __attribute__((format(ZTH_ATTR_PRINTF, 1, 2))) void zth_log(char const* fmt, ...);
#endif
 
#ifdef ZTH_OS_BAREMETAL
// newlib probably doesn't have these. Provide some default implementation for
// them.
EXTERN_C __attribute__((format(gnu_printf, 2, 0))) int asprintf(char** strp, const char* fmt, ...);
EXTERN_C __attribute__((format(gnu_printf, 2, 0))) int
vasprintf(char** strp, const char* fmt, va_list ap);
#endif
 
#endif // ZTH_UTIL_H