allocator.h

Go to the documentation of this file.

#ifndef ZTH_ALLOCATOR_H
#define ZTH_ALLOCATOR_H
/*
 * SPDX-FileCopyrightText: 2019-2026 Jochem Rutgers
 *
 * SPDX-License-Identifier: MPL-2.0
 */
 
#include <libzth/macros.h>
 
#ifdef __cplusplus
 
#  include <libzth/config.h>
#  include <libzth/util.h>
 
#  include <exception>
#  include <list>
#  include <map>
#  include <set>
#  include <string>
#  include <vector>
 
namespace zth {
 
#  ifdef NDEBUG
#    define ZTH_MALLOC_INLINE inline
#    define ZTH_MALLOC_ATTR(attr)
#  else
#    define ZTH_MALLOC_INLINE __attribute__((noinline))
#    if !defined(__clang_analyzer__) && GCC_VERSION >= 110000L
#      define ZTH_MALLOC_ATTR(attr) __attribute__(attr)
#    else
#      define ZTH_MALLOC_ATTR(attr) __attribute__((malloc))
#    endif
#  endif
 
template <typename T>
static ZTH_MALLOC_INLINE void deallocate(T* p, size_t n = 1) noexcept
{
        if(!p)
                return;
 
        typename Config::Allocator<T>::type allocator;
        allocator.deallocate(p, n);
}
 
template <typename T>
static ZTH_MALLOC_INLINE void delete_alloc(T* p) noexcept
{
        if(unlikely(!p))
                return;
 
        p->~T();
        deallocate(p);
}
 
template <typename T>
__attribute__((warn_unused_result, returns_nonnull)) ZTH_MALLOC_ATTR(
        (malloc((void (*)(T*, size_t) noexcept)deallocate, 1),
         alloc_size(1))) static ZTH_MALLOC_INLINE T* allocate(size_t n = 1)
{
        typename Config::Allocator<T>::type allocator;
        return allocator.allocate(n);
}
 
template <typename T>
__attribute__((warn_unused_result)) ZTH_MALLOC_ATTR(
        (malloc((void (*)(T*, size_t) noexcept)deallocate, 1),
         alloc_size(1))) static ZTH_MALLOC_INLINE T* allocate_noexcept(size_t n = 1) noexcept
{
        try {
                return allocate<T>(n);
        } catch(std::bad_alloc const&) {
                return nullptr;
        } catch(...) {
                zth_terminate();
        }
 
        // Should not get here.
        return nullptr;
}
 
template <typename T>
__attribute__((warn_unused_result, returns_nonnull)) ZTH_MALLOC_ATTR(
        (malloc((void (*)(T*) noexcept)delete_alloc))) static ZTH_MALLOC_INLINE T* new_alloc()
{
        T* o = allocate<T>();
        try {
                new(o) T;
                return o;
        } catch(...) {
                deallocate(o);
                zth_throw();
        } // cppcheck-suppress missingReturn
 
        // Should not get here.
}
 
template <typename T, typename Arg>
__attribute__((warn_unused_result, returns_nonnull)) ZTH_MALLOC_ATTR((malloc(
        (void (*)(T*) noexcept)delete_alloc))) static ZTH_MALLOC_INLINE T* new_alloc(Arg const& arg)
{
        T* o = allocate<T>();
        try {
                new(o) T(arg);
                return o;
        } catch(...) {
                deallocate(o);
                zth_throw();
        } // cppcheck-suppress missingReturn
 
        // Should not get here.
}
 
#  if __cplusplus >= 201103L
template <typename T, typename... Arg>
__attribute__((warn_unused_result, returns_nonnull)) ZTH_MALLOC_ATTR((malloc(
        (void (*)(T*) noexcept)delete_alloc))) static ZTH_MALLOC_INLINE T* new_alloc(Arg&&... arg)
{
        T* o = allocate<T>();
        try {
                new(o) T{std::forward<Arg>(arg)...};
                return o;
        } catch(...) {
                deallocate(o);
                zth_throw();
        } // cppcheck-suppress missingReturn
 
        // Should not get here.
}
#  endif
 
// cppcheck-suppress-macro duplInheritedMember
#  define ZTH_CLASS_NEW_DELETE(T)                                                             \
  public:                                                                                     \
          static ZTH_MALLOC_INLINE void operator delete(void* ptr) noexcept                   \
          {                                                                                   \
                  ::zth::deallocate<T>(static_cast<T*>(ptr));                                 \
          }                                                                                   \
          ZTH_MALLOC_ATTR((malloc, alloc_size(1)))                                            \
          __attribute__((warn_unused_result, returns_nonnull)) static ZTH_MALLOC_INLINE void* \
          operator new(std::size_t UNUSED_PAR(n))                                             \
          {                                                                                   \
                  zth_assert(n == sizeof(T));                                                 \
                  return ::zth::allocate<T>();                                                \
          }                                                                                   \
          static ZTH_MALLOC_INLINE void operator delete[](void* ptr, size_t sz) noexcept      \
          {                                                                                   \
                  zth_assert(sz % sizeof(T) == 0);                                            \
                  ::zth::deallocate<T>(static_cast<T*>(ptr), sz / sizeof(T));                 \
          }                                                                                   \
          ZTH_MALLOC_ATTR((malloc, alloc_size(1)))                                            \
          __attribute__((warn_unused_result, returns_nonnull)) static ZTH_MALLOC_INLINE void* \
          operator new[](std::size_t sz)                                                      \
          {                                                                                   \
                  zth_assert(sz % sizeof(T) == 0);                                            \
                  return ::zth::allocate<T>(sz / sizeof(T));                                  \
          }                                                                                   \
          typedef typename zth::Config::Allocator<T>::type allocator_type; /* NOLINT */       \
                                                                                              \
  private:
 
template <typename T>
struct vector_type {
        typedef std::vector<T, typename Config::Allocator<T>::type> type;
};
 
template <typename Key, typename T, typename Compare = std::less<Key> >
struct map_type {
        typedef std::map<
                Key, T, Compare, typename Config::Allocator<std::pair<const Key, T> >::type>
                type;
};
 
template <typename Key, typename Compare = std::less<Key> >
struct set_type {
        typedef std::set<Key, Compare, typename Config::Allocator<Key>::type> type;
};
 
template <typename T>
struct list_type {
        typedef std::list<T, typename Config::Allocator<T>::type> type;
};
 
template <typename Traits, typename Allocator>
string to_zth_string(std::basic_string<char, Traits, Allocator> const& s)
{
        return string(s.data(), s.size());
}
 
inline std::string to_std_string(string const& s)
{
        return std::string(s.data(), s.size());
}
 
} // namespace zth
#endif // __cplusplus
#endif // ZTH_ALLOCATOR_H