struct ExamplePlatform : PlatformContext
{
    void initializeHardware() QUL_DECL_OVERRIDE;
    void initializePlatform() QUL_DECL_OVERRIDE;
    void process() QUL_DECL_OVERRIDE;
    double rand() QUL_DECL_OVERRIDE;
    void resume() QUL_DECL_OVERRIDE;
    void waitUntil(uint64_t deadlineTimestampMs) QUL_DECL_OVERRIDE;
    uint64_t currentTimestamp() QUL_DECL_OVERRIDE;
    void consoleWrite(char character) QUL_DECL_OVERRIDE;

PlatformContext *getPlatformInstance()
{
    static ExamplePlatform platform;
    return &platform;
}

void ExamplePlatform::initializeHardware()
{
#if 0
    Replace the following code with actual code for your device.

    setup_system_clocks();
    setup_flash_memory();
    setup_sd_ram();
    setup_usart();
    setup_rnd_generator();
#endif
}
    ...

void PlatformContext::intializePlatform() {
    Qul::PlatformInterface::log("Called platform initialization\n");
}

uint64_t ExamplePlatform::currentTimestamp()
{
    // Replace this line to make it return the system timestamp in milliseconds.
    return 0;
}

void ExamplePlatform::process()
{
    // Read touch data, poll other peripherals that need regular attention, etc.

    logFlush(); // Flush partially filled log buffer
}

void ExamplePlatform::waitUntil(uint64_t deadlineTimestampMs)
{
    if (deadlineTimestampMs <= this->currentTimestamp())
        return; // deadlineTimestampMs already passed - return immediately

    // Replace this loop with your platform's real wait primitive (WFI, xSemaphoreTake(),
    // k_sem_take(), etc.), checking m_pendingResume so an early resume() isn't missed.
    while (!m_pendingResume && this->currentTimestamp() < deadlineTimestampMs) {
        // The device may yield or go into sleep mode
    }
    m_pendingResume = false;
}

void ExamplePlatform::resume()
{
    // Sticky: seen by waitUntil() even if resume() is called before it, e.g. from an
    // interrupt that fires while Qul::Application::update() is still running. This
    // function must be safe to call from an interrupt.
    m_pendingResume = true;
}

void BaremetalPlatform::waitUntil(uint64_t deadlineTimestampMs)
{
    const uint64_t now = currentTimestamp();
    if (deadlineTimestampMs <= now)
        return; // deadlineTimestampMs already passed - return immediately

    if (deadlineTimestampMs != std::numeric_limits<uint64_t>::max()) {
        const uint64_t delta = deadlineTimestampMs - now;
        // fire an interrupt after delta ms (or maximum supported hardware timer duration if delta ms exceeds that)
        programHardwareTimer(delta);
    }

    __disable_irq();
    if (!m_pendingResume)
        __WFI();
    m_pendingResume = false;
    __enable_irq();
}

// Called from ISR or event sources; sets a flag so WFI in waitUntil() returns immediately.
void BaremetalPlatform::resume()
{
    m_pendingResume = true; // seen by waitUntil() even if called before it
}

Qul::initHardware(); // Optional
Qul::initPlatform();
Qul::Application app;
static struct Main item;
app.setRootItem(&item);
while (true) {
    const uint64_t nextUpdate = app.update();
    app.waitUntil(nextUpdate);
}

double ExamplePlatform::rand()
{
    // Replace std::rand() by the proper call to the random number generator on your device, if available.
    const uint32_t number = std::rand();
    return number / (std::numeric_limits<uint32_t>::max() + 1.0);
}

void *qul_malloc(std::size_t size)
{
    return std::malloc(size);
}

void qul_free(void *ptr)
{
    std::free(ptr);
}

void *qul_realloc(void *ptr, size_t s)
{
    return std::realloc(ptr, s);
}

// The number of times an internal timing event occurs per second
int const CLOCKS_PER_SECOND = 1000;

clock_t clock(void)
{
    QUL_UNUSED(CLOCKS_PER_SECOND);

    // This function should return a value, which after division by CLOCKS_PER_SECOND,
    // is the processor time in seconds.
    return (clock_t) HAL_GetTick();
}

// The time_t type is defined in bxarm/arm/inc/c/time{32,64}.h
#if _DLIB_TIME_USES_64
time_t __time64(time_t *t)
#else
time_t __time32(time_t *t)
#endif
{
    uint64_t timeAtStartup = 0; // Read this from a time source like a real time clock;
    uint64_t currentTimestamp = timestamp();
    // same timestamp as _gettimeofday
    time_t curtime = (time_t) (timeAtStartup + (currentTimestamp / 1000));

    if (t)
        *t = curtime;

    return curtime;
}

char const *__getzone()
{
    // See <IAR>/src/lib/time/getzone.c for documentation
    // For Germany as a default timezone
    return ":GMT+1:GMT+2:0100:032502+0:102502+0";
}

__ATTRIBUTES char *_DstMalloc(size_t);
__ATTRIBUTES void _DstFree(char *);

char *_DstMalloc(size_t s)
{
    // Return a buffer that can hold the maximum number of DST entries of
    // of any timezone available on the device.
    // Each DST entry takes up a structure of 5 bytes plus regular alignment.
    // Instead of a static buffer a dynamically allocated memory can be used as well.

    // With the two entries shown above the required buffer size would be
    // 2 * (5 bytes size + 3 bytes alignment) = 16 bytes

    static char buffert[8 * 4];
    return buffert;
}

void _DstFree(char *p)
{
    // Nothing required here because of static buffer in _DstMalloc
    QUL_UNUSED(p);
}