ustd_functional.h

// This implementation of functionals for low-resource AVRs
// is completely based on: project function-avr by
// https://github.com/winterscar, see:
// https://github.com/winterscar/functional-avr

/*! \file ustd_functional.h
std::function<> equivalent for low-resource AVRs

ustd_functional.h is a minimal, no-dependency implementation of functionals
for AVRs, taken from project:
<a href="https://github.com/winterscar/functional-avr">functional-avr</a> by winterscar.

Make sure to provide the
<a href="https://github.com/muwerk/ustd/blob/master/README.md">required platform
define</a> before including ustd headers.

Note: if you are only interested in using functionals, it might be better
to directly use project <a href="https://github.com/winterscar/functional-avr">functional-avr</a> by
winterscar.

## An example:

~~~{.cpp}
#define __UNO__ 1     // Appropriate platform define required
                      // Note: only __ARDUINO__ is supported.
                      // __ATTINY__ is no longer supported.
                      // All other platforms should use std::function<>
                      // from standard library.
#include <ustd_functional.h>

#if defined (__ARDUINO__)
typedef ustd::function<void()> T_TASK;
#else // use standard library instead:
typedef std::function<void()> T_TASK;
#endif

void task(T_TASK *tsk) {
    tsk();
}

class Something {
    Something() {
        auto ft = [=]() { this->callback(); };
        task(ft);
    }
    void callback() {
        // do something
    }
}
~~~
*/
#pragma once

#if defined __ATTINY__ || defined(__ARDUINO__) || defined(__ARM__) || defined(__RISC_V__)
// ATTINY is broken currently.
// using size_t = decltype(sizeof(int));

#ifdef __ATTINY__
#include <Arduino.h>
using nullptr_t = decltype(nullptr);
#endif

// NEW_H is some new Arduino implementation of new operator
#if !defined(NEW_H) && !defined(USTD_FEATURE_SUPPORTS_NEW_OPERATOR)
inline void *operator new(size_t size, void *ptr) {
    return ptr;
}
#endif

namespace ustd {

template <class T> struct tag { using type = T; };
template <class Tag> using type_t = typename Tag::type;

// using size_t=decltype(sizeof(int));

// move

template <class T> T &&move(T &t) {
    return static_cast<T &&>(t);
}

// forward

template <class T> struct remove_reference : tag<T> {};
template <class T> struct remove_reference<T &> : tag<T> {};
template <class T> using remove_reference_t = type_t<remove_reference<T>>;

template <class T> T &&forward(remove_reference_t<T> &t) {
    return static_cast<T &&>(t);
}
template <class T> T &&forward(remove_reference_t<T> &&t) {
    return static_cast<T &&>(t);
}

// decay

template <class T> struct remove_const : tag<T> {};
template <class T> struct remove_const<T const> : tag<T> {};

template <class T> struct remove_volatile : tag<T> {};
template <class T> struct remove_volatile<T volatile> : tag<T> {};

template <class T> struct remove_cv : remove_const<type_t<remove_volatile<T>>> {};

template <class T> struct decay3 : remove_cv<T> {};
template <class R, class... Args> struct decay3<R(Args...)> : tag<R (*)(Args...)> {};
template <class T> struct decay2 : decay3<T> {};
template <class T, size_t N> struct decay2<T[N]> : tag<T *> {};

template <class T> struct decay : decay2<remove_reference_t<T>> {};

template <class T> using decay_t = type_t<decay<T>>;

// is_convertible

template <class T> T declval();  // no implementation

template <class T, T t> struct integral_constant {
    static constexpr T value = t;
    constexpr integral_constant(){};
    constexpr operator T() const {
        return value;
    }
    constexpr T operator()() const {
        return value;
    }
};
template <bool b> using bool_t = integral_constant<bool, b>;
using true_type = bool_t<true>;
using false_type = bool_t<false>;

template <class...> struct voider : tag<void> {};
template <class... Ts> using void_t = type_t<voider<Ts...>>;

namespace details {
template <template <class...> class Z, class, class... Ts> struct can_apply : false_type {};
template <template <class...> class Z, class... Ts>
struct can_apply<Z, void_t<Z<Ts...>>, Ts...> : true_type {};
}  // namespace details
template <template <class...> class Z, class... Ts>
using can_apply = details::can_apply<Z, void, Ts...>;

namespace details {
template <class From, class To> using try_convert = decltype(To{declval<From>()});
}
template <class From, class To>
struct is_convertible : can_apply<details::try_convert, From, To> {};
template <> struct is_convertible<void, void> : true_type {};

// enable_if

template <bool, class = void> struct enable_if {};
template <class T> struct enable_if<true, T> : tag<T> {};
template <bool b, class T = void> using enable_if_t = type_t<enable_if<b, T>>;

// res_of

namespace details {
template <class G, class... Args> using invoke_t = decltype(declval<G>()(declval<Args>()...));

template <class Sig, class = void> struct res_of {};
template <class G, class... Args>
struct res_of<G(Args...), void_t<invoke_t<G, Args...>>> : tag<invoke_t<G, Args...>> {};
}  // namespace details
template <class Sig> using res_of = details::res_of<Sig>;
template <class Sig> using res_of_t = type_t<res_of<Sig>>;

// aligned_storage

template <size_t size, size_t align> struct alignas(align) aligned_storage_t { char buff[size]; };

// is_same

template <class A, class B> struct is_same : false_type {};
template <class A> struct is_same<A, A> : true_type {};

template <class Sig, size_t sz, size_t algn> struct small_task;

template <class R, class... Args, size_t sz, size_t algn> struct small_task<R(Args...), sz, algn> {
    struct vtable_t {
        void (*mover)(void *src, void *dest);
        void (*destroyer)(void *);
        R (*invoke)(void const *t, Args &&...args);
        template <class T> static vtable_t const *get() {
            static const vtable_t table = {
                [](void *src, void *dest) { new (dest) T(move(*static_cast<T *>(src))); },
                [](void *t) { static_cast<T *>(t)->~T(); },
                [](void const *t, Args &&...args) -> R {
                    return (*static_cast<T const *>(t))(forward<Args>(args)...);
                }};
            return &table;
        }
    };
    vtable_t const *table = nullptr;
    aligned_storage_t<sz, algn> data;
    template <class F, class dF = decay_t<F>, enable_if_t<!is_same<dF, small_task>{}> * = nullptr,
              enable_if_t<is_convertible<res_of_t<dF &(Args...)>, R>{}> * = nullptr>
    small_task(F &&f) : table(vtable_t::template get<dF>()) {
        static_assert(sizeof(dF) <= sz, "object too large");
        static_assert(alignof(dF) <= algn, "object too aligned");
        new (&data) dF(forward<F>(f));
    }
    ~small_task() {
        if (table)
            table->destroyer(&data);
    }
    small_task(const small_task &o) : table(o.table) {
        data = o.data;
    }
    small_task(small_task &&o) : table(o.table) {
        if (table)
            table->mover(&o.data, &data);
    }
    small_task() {
    }
    small_task &operator=(const small_task &o) {
        this->~small_task();
        new (this) small_task(move(o));
        return *this;
    }
    small_task &operator=(small_task &&o) {
        this->~small_task();
        new (this) small_task(move(o));
        return *this;
    }
    explicit operator bool() const {
        return table;
    }
    R operator()(Args... args) const {
        return table->invoke(&data, forward<Args>(args)...);
    }
};

template <class R, class... Args, size_t sz, size_t algn>
inline bool operator==(const small_task<R(Args...), sz, algn> &__f, nullptr_t) {
    return !static_cast<bool>(__f);
}

/// @overload
template <class R, class... Args, size_t sz, size_t algn>
inline bool operator==(nullptr_t, const small_task<R(Args...), sz, algn> &__f) {
    return !static_cast<bool>(__f);
}

template <class R, class... Args, size_t sz, size_t algn>
inline bool operator!=(const small_task<R(Args...), sz, algn> &__f, nullptr_t) {
    return static_cast<bool>(__f);
}

/// @overload
template <class R, class... Args, size_t sz, size_t algn>
inline bool operator!=(nullptr_t, const small_task<R(Args...), sz, algn> &__f) {
    return static_cast<bool>(__f);
}

template <class Sig> using function = small_task<Sig, sizeof(void *) * 4, alignof(void *)>;
}  // namespace ustd

#endif