allocator.h

Go to the documentation of this file.

#ifndef ZTH_ALLOCATOR_H
#define ZTH_ALLOCATOR_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/.
 */
 
#ifdef __cplusplus
 
#       include <libzth/macros.h>
#       include <libzth/config.h>
#       include <libzth/util.h>
 
#       include <list>
#       include <map>
#       include <string>
#       include <vector>
 
namespace zth {
 
template <typename T>
__attribute__((warn_unused_result, returns_nonnull)) static inline T* allocate(size_t n = 1)
{
        typename Config::Allocator<T>::type allocator;
        return allocator.allocate(n);
}
 
template <typename T>
__attribute__((warn_unused_result)) static inline T* allocate_noexcept(size_t n = 1) noexcept
{
        try {
                return allocate<T>(n);
        } catch(...) {
        }
        return nullptr;
}
 
template <typename T>
__attribute__((warn_unused_result)) static inline T* new_alloc()
{
        T* o = allocate<T>(1);
        new(o) T;
        return o;
}
 
template <typename T, typename Arg>
__attribute__((warn_unused_result)) static inline T* new_alloc(Arg const& arg)
{
        T* o = allocate<T>(1);
        new(o) T(arg);
        return o;
}
 
#       if __cplusplus >= 201103L
template <typename T, typename... Arg>
__attribute__((warn_unused_result)) static inline T* new_alloc(Arg&&... arg)
{
        T* o = allocate<T>(1);
        new(o) T(std::forward<Arg>(arg)...);
        return o;
}
#       endif
 
template <typename T>
static 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 inline void delete_alloc(T* p) noexcept
{
        if(unlikely(!p))
                return;
 
        p->~T();
        deallocate(p, 1);
}
 
#       define ZTH_CLASS_NEW_DELETE(T)                             \
        public:                                                     \
                void* operator new(std::size_t UNUSED_PAR(n))       \
                {                                                   \
                        zth_assert(n == sizeof(T));                 \
                        return ::zth::allocate<T>();                \
                }                                                   \
                void operator delete(void* ptr)                     \
                {                                                   \
                        ::zth::deallocate<T>(static_cast<T*>(ptr)); \
                }                                                   \
                                                                    \
        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 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