Classes
class	bnb::interfaces::egl_context

class	bnb::interfaces::image_releaser
	Only android interface. More...

class	bnb::interfaces::log_record_callback

struct	bnb::subscription_request_t

class	bnb::base_event_iface

class	bnb::base_event< Event, MaxElements >

class	bnb::time_stamped_event< Event >

class	bnb::simple_event< T, Count >

class	bnb::empty_event< Count >

class	bnb::effect_event

class	bnb::identified_class< IdType, T >

class	bnb::spin_lock

class	bnb::spin_mutex

struct	bnb::static_pool_allocator< T, MAX_ELEMENTS >
	Doesn't support N allocs (std::vector) More...

struct	bnb::static_pool_allocator< T, MAX_ELEMENTS >::rebind< U >

class	bnb::static_pool_allocator_fallback< T, MAX_ELEMENTS, Alloc_fallback >

class	bnb::singleton< T >
	Base class for all scoped singletons. More...

Macros
#define	BNB_EXPORT __attribute__((__visibility__("default")))

#define	BNB_OS_ANDROID 0

#define	BNB_OS_IOS 0

#define	BNB_OS_LINUX 0

#define	BNB_OS_MACOS 0

#define	BNB_OS_EMSCRIPTEN 0

#define	BNB_OS_UNIX 0

#define	BNB_OS_WINDOWS 0

#define	BNB_OS_WINDOWS_ARM64 0

#define	BNB_APPLE 0

#define	BNB_ASSERT(expr)

#define	BNB_ASSERT_MSG(expr, msg)

#define	BNB_CHECK(expr)

#define	BNB_CHECK_MSG(expr, msg)

Typedefs
using	bnb::event_id_t = size_t

using	bnb::handler_id_t = size_t

using	bnb::base_event_ptr = std::shared_ptr<const base_event_iface>

using	bnb::base_event_deleter = std::function<void(const bnb::base_event_iface*)>

template<typename T >
using	bnb::event_uptr = std::unique_ptr<T, base_event_deleter>

using	bnb::base_event_uptr = event_uptr<const base_event_iface>

typedef char	char8_t

Functions
template<typename T , typename... Args>
std::unique_ptr< T, base_event_deleter >	bnb::make_unique_event (Args &&... args)

template<typename T , typename Alloc , typename D , typename... Args>
std::unique_ptr< T, D >	bnb::allocate_unique (Alloc alloc, Args &&... args)

template<typename Class >
size_t	bnb::class_unique_id ()

T *	bnb::static_pool_allocator< T, MAX_ELEMENTS >::allocate (std::size_t n)

T *	bnb::static_pool_allocator< T, MAX_ELEMENTS >::allocate (std::size_t n, const std::nothrow_t &) noexcept

void	bnb::static_pool_allocator< T, MAX_ELEMENTS >::deallocate (T *p, std::size_t n)

bool	bnb::static_pool_allocator< T, MAX_ELEMENTS >::is_mine (T *p)

Detailed Description

Macro Definition Documentation

◆ BNB_APPLE

#define BNB_APPLE 0

Definition at line 126 of file defs.hpp.

◆ BNB_ASSERT

#define BNB_ASSERT ( expr )

Value:

assert(expr)

Definition at line 11 of file assert.hpp.

◆ BNB_ASSERT_MSG

#define BNB_ASSERT_MSG	(		expr,
			msg )

Value:

assert((expr) && (msg))

Definition at line 12 of file assert.hpp.

◆ BNB_CHECK

#define BNB_CHECK ( expr )

Value:

    if (!(expr)) {                          \
        BNB_THROW(std::logic_error, #expr); \
    }

Definition at line 14 of file assert.hpp.

#define BNB_CHECK(expr)                     \
    if (!(expr)) {                          \
        BNB_THROW(std::logic_error, #expr); \
    }

◆ BNB_CHECK_MSG

#define BNB_CHECK_MSG	(		expr,
			msg )

Value:

    if (!(expr)) {                                                    \
        BNB_THROW(std::logic_error, std::string(msg) + ": " + #expr); \
    }

Definition at line 19 of file assert.hpp.

#define BNB_CHECK_MSG(expr, msg)                                      \
    if (!(expr)) {                                                    \
        BNB_THROW(std::logic_error, std::string(msg) + ": " + #expr); \
    }

◆ BNB_EXPORT

#define BNB_EXPORT __attribute__((__visibility__("default")))

Definition at line 22 of file defs.hpp.

◆ BNB_OS_ANDROID

#define BNB_OS_ANDROID 0

Definition at line 27 of file defs.hpp.

◆ BNB_OS_EMSCRIPTEN

#define BNB_OS_EMSCRIPTEN 0

Definition at line 83 of file defs.hpp.

◆ BNB_OS_IOS

#define BNB_OS_IOS 0

Definition at line 41 of file defs.hpp.

◆ BNB_OS_LINUX

#define BNB_OS_LINUX 0

Definition at line 55 of file defs.hpp.

◆ BNB_OS_MACOS

#define BNB_OS_MACOS 0

Definition at line 69 of file defs.hpp.

◆ BNB_OS_UNIX

#define BNB_OS_UNIX 0

Definition at line 97 of file defs.hpp.

◆ BNB_OS_WINDOWS

#define BNB_OS_WINDOWS 0

Definition at line 110 of file defs.hpp.

◆ BNB_OS_WINDOWS_ARM64

#define BNB_OS_WINDOWS_ARM64 0

Definition at line 111 of file defs.hpp.

Typedef Documentation

◆ base_event_deleter

using bnb::base_event_deleter = std::function<void(const bnb::base_event_iface*)>

Definition at line 111 of file event.hpp.

◆ base_event_ptr

using bnb::base_event_ptr = std::shared_ptr<const base_event_iface>

Definition at line 110 of file event.hpp.

◆ base_event_uptr

using bnb::base_event_uptr = event_uptr<const base_event_iface>

Definition at line 116 of file event.hpp.

◆ char8_t

typedef char char8_t

Definition at line 144 of file defs.hpp.

◆ event_id_t

using bnb::event_id_t = size_t

Definition at line 22 of file event.hpp.

◆ event_uptr

template<typename T >

using bnb::event_uptr = std::unique_ptr<T, base_event_deleter>

Definition at line 114 of file event.hpp.

◆ handler_id_t

using bnb::handler_id_t = size_t

Definition at line 23 of file event.hpp.

Function Documentation

◆ allocate() [1/2]

template<typename T , size_t MAX_ELEMENTS>

T * bnb::static_pool_allocator< T, MAX_ELEMENTS >::allocate ( std::size_t n )

inline

Definition at line 103 of file static_pool_allocator.hpp.

    {
        spin_lock l(static_data.pool_lock);
 
        if (!_have_free() || n > 1)
            throw std::bad_alloc();
 
        return _allocate();
    }

◆ allocate() [2/2]

template<typename T , size_t MAX_ELEMENTS>

T * bnb::static_pool_allocator< T, MAX_ELEMENTS >::allocate	(	std::size_t	n,
		const std::nothrow_t &	)

inlinenoexcept

Definition at line 114 of file static_pool_allocator.hpp.

    {
        spin_lock l(static_data.pool_lock);
 
        if (!_have_free() || n > 1)
            return nullptr;
 
        return _allocate();
    }

◆ allocate_unique()

template<typename T , typename Alloc , typename D , typename... Args>

std::unique_ptr< T, D > bnb::allocate_unique	(	Alloc	alloc,
		Args &&...	args )

inline

Definition at line 13 of file allocate_unique.hpp.

    {
        using traits = std::allocator_traits<Alloc>;
        auto ptr = traits::allocate(alloc, 1);
        try {
            traits::construct(alloc, ptr, std::forward<Args>(args)...);
        } catch (...) {
            traits::deallocate(alloc, ptr, 1);
            throw;
        }
 
 
        return std::unique_ptr<T, D>(
            ptr,
            [alloc = std::move(alloc)](auto p) mutable {
                auto ptr = const_cast<T*>(reinterpret_cast<const T*>(p));
                traits::destroy(alloc, ptr);
                traits::deallocate(alloc, ptr, 1);
            }
        );
    }

◆ class_unique_id()

template<typename Class >

size_t bnb::class_unique_id ( )

Definition at line 11 of file class_unique_id.hpp.

    {
        static const char registrar_slot = 0;
        return reinterpret_cast<size_t>(&registrar_slot);
    }

◆ deallocate()

template<typename T , size_t MAX_ELEMENTS>

void bnb::static_pool_allocator< T, MAX_ELEMENTS >::deallocate	(	T *	p,
		std::size_t	n )

inline

Definition at line 136 of file static_pool_allocator.hpp.

    {
        (void) n;
        spin_lock l(static_data.pool_lock);
 
        const size_t slot = (reinterpret_cast<unsigned char*>(p) - reinterpret_cast<unsigned char*>(static_data.pool)) / sizeof(T);
        *static_data.free_slots_end = slot;
        ++static_data.free_slots_end;
    }

◆ is_mine()

template<typename T , size_t MAX_ELEMENTS>

bool bnb::static_pool_allocator< T, MAX_ELEMENTS >::is_mine ( T * p )

inline

Definition at line 155 of file static_pool_allocator.hpp.

    {
        if (reinterpret_cast<char*>(p) < reinterpret_cast<char*>(static_data.pool) || reinterpret_cast<char*>(p) > reinterpret_cast<char*>(static_data.pool) + sizeof(static_data.pool))
            return false;
        return true;
    }

◆ make_unique_event()

template<typename T , typename... Args>

std::unique_ptr< T, base_event_deleter > bnb::make_unique_event ( Args &&... args )

inline

Definition at line 120 of file event.hpp.

    {
        return allocate_unique<T, typename T::allocator, base_event_deleter, Args&&...>(
            typename T::allocator(),
            std::forward<Args>(args)...
        );
    }

◆ static_data_t()

template<typename T , size_t MAX_ELEMENTS>

bnb::static_pool_allocator< T, MAX_ELEMENTS >::static_data_t::static_data_t ( )

Definition at line 92 of file static_pool_allocator.hpp.

        : pool(bnb::static_pool<T, MAX_ELEMENTS>)
    {
        int i = 0;
        std::generate(free_slots.begin(), free_slots.end(), [i]() mutable { return i++; });
        free_slots_end = free_slots.end();
        pool_lock.clear();
    }

Classes

Macros

Typedefs

Functions

Detailed Description

Macro Definition Documentation

◆ BNB_APPLE

◆ BNB_ASSERT

◆ BNB_ASSERT_MSG

◆ BNB_CHECK

◆ BNB_CHECK_MSG

◆ BNB_EXPORT

◆ BNB_OS_ANDROID

◆ BNB_OS_EMSCRIPTEN

◆ BNB_OS_IOS

◆ BNB_OS_LINUX

◆ BNB_OS_MACOS

◆ BNB_OS_UNIX

◆ BNB_OS_WINDOWS

◆ BNB_OS_WINDOWS_ARM64

Typedef Documentation

◆ base_event_deleter

◆ base_event_ptr

◆ base_event_uptr

◆ char8_t

◆ event_id_t

◆ event_uptr

◆ handler_id_t

Function Documentation

◆ allocate() [1/2]

◆ allocate() [2/2]

◆ allocate_unique()

◆ class_unique_id()

◆ deallocate()

◆ is_mine()

◆ make_unique_event()

◆ static_data_t()