autoalloc.h

Go to the documentation of this file.

/*===========================================================================
     _____        _____        _____        _____
 ___|    _|__  __|_    |__  __|__   |__  __| __  |__  ______
|    \  /  | ||    \      ||     |     ||  |/ /     ||___   |
|     \/   | ||     \     ||     \     ||     \     ||___   |
|__/\__/|__|_||__|\__\  __||__|\__\  __||__|\__\  __||______|
    |_____|      |_____|      |_____|      |_____|

--[Mark3 Realtime Platform]--------------------------------------------------

Copyright (c) 2012 - 2019 m0slevin, all rights reserved.
See license.txt for more information
=========================================================================== */
#pragma once

#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include "mark3cfg.h"

namespace Mark3
{
//---------------------------------------------------------------------------
// Define function pointer types used for interfacing with an external heap.
//---------------------------------------------------------------------------
enum class AutoAllocType : uint8_t {
    //-- Kernel object types
    EventFlag,
    MailBox,
    Message,
    MessagePool,
    MessageQueue,
    Mutex,
    Notify,
    Semaphore,
    Thread,
    Timer,
    ConditionVariable,
    ReaderWriterLock,
    Coroutine,
    //-- Allow for users to define their own object types beginning with AutoAllocType_t::User
    User,
    //--
    Raw = 0xFF
};

//---------------------------------------------------------------------------
using AutoAllocAllocator_t = void* (*)(AutoAllocType eType_, size_t sSize_);
using AutoAllocFree_t      = void (*)(AutoAllocType eType_, void* pvObj_);

//---------------------------------------------------------------------------
// Forward declaration of kernel objects that can be auotomatically allocated.


class AutoAlloc
{
public:
    static void Init(void);

    static void SetAllocatorFunctions(AutoAllocAllocator_t pfAllocator_, AutoAllocFree_t pfFree_);

    template <typename T, AutoAllocType e> static T* NewObject()
    {
        auto* pvObj = Allocate(e, sizeof(T));
        if (pvObj) {
            return new (pvObj) T();
        }
        return 0;
    }

    template <typename T, AutoAllocType e> static void DestroyObject(T* pObj_)
    {
        pObj_->~T();
        Free(e, pObj_);
    }

    static void* NewUserTypeAllocation(uint8_t eUserType_);

    static void DestroyUserTypeAllocation(uint8_t eUserType_, void* pvObj_);

    static void* NewRawData(size_t sSize_);

    static void DestroyRawData(void* pvData_);

private:
    static void* Allocate(AutoAllocType eType_, size_t sSize_);
    static void  Free(AutoAllocType eType_, void* pvObj_);

    static AutoAllocAllocator_t m_pfAllocator; 
    static AutoAllocFree_t      m_pfFree;      
};
} // namespace Mark3