future.h

Go to the documentation of this file.

//   Copyright 2016-2023 Jean-Francois Poilpret
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.
 
 
#ifndef FUTURE_HH
#define FUTURE_HH
 
#include <string.h>
#include "flash.h"
#include "interrupts.h"
#include "iterator.h"
#include "errors.h"
#include "time.h"
 
#define REGISTER_FUTURE_STATUS_LISTENERS(ABSTRACT_TYPE, HANDLER1, ...)                              \
    namespace future                                                                                \
    {                                                                                               \
        void future_on_status_change_dispatch(const AbstractFuture& future, FutureStatus status)    \
        {                                                                                           \
            dispatch_handler<ABSTRACT_TYPE, AbstractFuture>::future_on_status_change<               \
                HANDLER1, ##__VA_ARGS__>(future, status);                                           \
        }                                                                                           \
        void future_on_status_change_dispatch(const AbstractFakeFuture& future, FutureStatus status)\
        {                                                                                           \
            dispatch_handler<ABSTRACT_TYPE, AbstractFakeFuture>::future_on_status_change<           \
                HANDLER1, ##__VA_ARGS__>(future, status);                                           \
        }                                                                                           \
    }                                                                                               \
 
#define REGISTER_FUTURE_STATUS_NO_LISTENERS()                                                   \
    void future::future_on_status_change_dispatch(const AbstractFuture&, FutureStatus) {}       \
    void future::future_on_status_change_dispatch(const AbstractFakeFuture&, FutureStatus) {}
 
#define REGISTER_FUTURE_OUTPUT_LISTENERS(ABSTRACT_TYPE, HANDLER1, ...)                      \
    namespace future                                                                        \
    {                                                                                       \
        void future_on_output_change_dispatch(const AbstractFuture& future)                 \
        {                                                                                   \
            dispatch_handler<ABSTRACT_TYPE, AbstractFuture>::future_on_output_change<       \
                HANDLER1, ##__VA_ARGS__>(future);                                           \
        }                                                                                   \
        void future_on_output_change_dispatch(const AbstractFakeFuture& future)             \
        {                                                                                   \
            dispatch_handler<ABSTRACT_TYPE, AbstractFakeFuture>::future_on_output_change<   \
                HANDLER1, ##__VA_ARGS__>(future);                                           \
        }                                                                                   \
    }                                                                                       \
 
#define REGISTER_FUTURE_OUTPUT_NO_LISTENERS()                                   \
    void future::future_on_output_change_dispatch(const AbstractFuture&) {}     \
    void future::future_on_output_change_dispatch(const AbstractFakeFuture&) {}
 
#define REGISTER_FUTURE_NO_LISTENERS()      \
    REGISTER_FUTURE_STATUS_NO_LISTENERS()   \
    REGISTER_FUTURE_OUTPUT_NO_LISTENERS()
 
#define DECL_FUTURE_LISTENERS_FRIEND         \
    template<typename> friend struct future::dispatch_handler_impl;
 
namespace future
{
    enum class FutureStatus : uint8_t
    {
        NOT_READY = 0,
 
        READY,
 
        ERROR,
 
        INVALID
    };
 
    template<typename OSTREAM> OSTREAM& operator<<(OSTREAM& out, FutureStatus status)
    {
        // Conversion lambda for local usage
        auto convert = [](FutureStatus s)
        {
            switch (s)
            {
                case FutureStatus::NOT_READY:
                return F("NOT_READY");
 
                case FutureStatus::READY:
                return F("READY");
 
                case FutureStatus::ERROR:
                return F("ERROR");
 
                case FutureStatus::INVALID:
                return F("INVALID");
 
                default:
                return F("");
            }
        };
        return out << convert(status);
    }
 
    class AbstractFuture;
    extern void future_on_status_change_dispatch(const AbstractFuture&, FutureStatus);
    extern void future_on_output_change_dispatch(const AbstractFuture&);
    class AbstractFakeFuture;
    extern void future_on_status_change_dispatch(const AbstractFakeFuture&, FutureStatus);
    extern void future_on_output_change_dispatch(const AbstractFakeFuture&);
 
    enum class FutureNotification : uint8_t
    {
        NONE = 0,
        STATUS = 1,
        OUTPUT = 2,
        BOTH = 3
    };
 
    class AbstractFuture
    {
    public:
        FutureStatus status() const
        {
            return status_;
        }
 
        FutureStatus await() const
        {
            while (status_ == FutureStatus::NOT_READY)
                time::yield();
            return status_;
        }
 
        int error() const
        {
            switch (await())
            {
                case FutureStatus::ERROR:
                return error_;
 
                case FutureStatus::READY:
                return 0;
 
                default:
                // This should never happen
                return errors::EINVAL;
            }
        }
 
        // Methods called by a Future consumer
        //=====================================
 
        uint8_t get_storage_value_size_() const
        {
            return input_size_;
        }
 
        bool get_storage_value_(uint8_t& chunk)
        {
            // Check all bytes have not been transferred yet
            if (input_size_ == 0)
                return false;
            chunk = *input_current_++;
            --input_size_;
            return true;
        }
 
        bool get_storage_value_(uint8_t* chunk, uint8_t size)
        {
            // Check size does not go beyond transferrable size
            if (size > input_size_)
                return false;
            memcpy(chunk, input_current_, size);
            input_current_ += size;
            input_size_ -= size;
            return true;
        }
 
        // Methods called by a Future supplier
        //=====================================
 
        uint8_t get_future_value_size_() const
        {
            return output_size_;
        }
 
        bool set_future_finish_()
        {
            // Check this future is waiting for data
            if (status_ != FutureStatus::NOT_READY)
                return false;
            if (output_size_ == 0)
            {
                status_ = FutureStatus::READY;
                callback_status();
            }
            return true;
        }
 
        bool set_future_value_(uint8_t chunk)
        {
            // Check this future is waiting for data
            if (status_ != FutureStatus::NOT_READY)
                return false;
            // Update Future value chunk
            *output_current_++ = chunk;
            // Is that the last chunk?
            --output_size_;
            callback_output();
            if (output_size_ == 0)
            {
                status_ = FutureStatus::READY;
                callback_status();
            }
            return true;
        }
 
        bool set_future_value_(const uint8_t* chunk, uint8_t size)
        {
            // Check size does not go beyond expected size
            if (size > output_size_)
            {
                // Store error
                set_future_error_(errors::EMSGSIZE);
                return false;
            }
            while (size--)
            {
                if (!set_future_value_(*chunk++)) return false;
            }
            return true;
        }
 
        template<typename T> bool set_future_value_(const T& value)
        {
            return set_future_value_(reinterpret_cast<const uint8_t*>(&value), sizeof(T));
        }
 
        bool set_future_error_(int error)
        {
            // Check this future is waiting for data
            if ((error == 0) || (status_ != FutureStatus::NOT_READY))
                return false;
            error_ = error;
            status_ = FutureStatus::ERROR;
            callback_status();
            return true;
        }
 
    protected:
        // "default" constructor
        AbstractFuture(uint8_t* output_data, uint8_t output_size, uint8_t* input_data, uint8_t input_size,
            FutureNotification notifications = FutureNotification::NONE)
            :   output_data_{output_data}, output_current_{output_data}, output_size_{output_size},
                input_data_{input_data}, input_current_{input_data}, input_size_{input_size},
                notifications_{notifications} {}
 
        // these constructors are forbidden (subclass ctors shall call above move/copy ctor instead)
        AbstractFuture(const AbstractFuture&) = delete;
        AbstractFuture& operator=(const AbstractFuture&) = delete;
        AbstractFuture(AbstractFuture&&) = delete;
        AbstractFuture& operator=(AbstractFuture&&) = delete;
 
        ~AbstractFuture() = default;
 
        // This method is called by subclasses to completely reset this future (for reuse from scratch)
        void reset_(uint8_t* output_data, uint8_t output_size, uint8_t* input_data, uint8_t input_size)
        {
            status_ = FutureStatus::NOT_READY;
            error_ = 0;
            output_data_ = output_current_ = output_data;
            output_size_ = output_size;
            input_data_ = input_current_ = input_data;
            input_size_ = input_size;
        }
 
        // This method is called by subclass to check if input is replaceable,
        // i.e. it has not been read yet
        bool can_replace_input_() const
        {
            return (input_current_ == input_data_);
        }
 
    private:
        void callback_status()
        {
            if (uint8_t(notifications_) & uint8_t(FutureNotification::STATUS))
                future_on_status_change_dispatch(*this, status_);
        }
        
        void callback_output()
        {
            if (uint8_t(notifications_) & uint8_t(FutureNotification::OUTPUT))
                future_on_output_change_dispatch(*this);
        }
        
        volatile FutureStatus status_ = FutureStatus::NOT_READY;
        int error_ = 0;
 
        uint8_t* output_data_ = nullptr;
        uint8_t* output_current_ = nullptr;
        uint8_t output_size_ = 0;
        
        uint8_t* input_data_ = nullptr;
        uint8_t* input_current_ = nullptr;
        uint8_t input_size_ = 0;
 
        FutureNotification notifications_;
 
        template<typename F> friend class AbstractFuturesGroup;
    };
 
    template<typename OUT_ = void, typename IN_ = void>
    class Future : public AbstractFuture
    {
        static_assert(sizeof(OUT_) <= UINT8_MAX, "OUT type must be strictly smaller than 256 bytes");
        static_assert(sizeof(IN_) <= UINT8_MAX, "IN type must be strictly smaller than 256 bytes");
 
    public:
        using OUT = OUT_;
        using IN = IN_;
 
        static constexpr uint8_t OUT_SIZE = sizeof(OUT);
        static constexpr uint8_t IN_SIZE = sizeof(IN);
 
        explicit Future(const IN& input = IN{}, FutureNotification notifications = FutureNotification::NONE)
            :   AbstractFuture{output_buffer_, sizeof(OUT), input_buffer_, sizeof(IN), 
                    notifications}, input_{input} {}
 
        ~Future() = default;
 
        void reset_(const IN& input = IN{})
        {
            AbstractFuture::reset_(output_buffer_, sizeof(OUT), input_buffer_, sizeof(IN));
            input_ = input;
        }
 
        bool reset_input_(const IN& input)
        {
            if (!can_replace_input_()) return false;
            input_ = input;
            return true;
        }
 
        bool get(OUT& result)
        {
            if (await() != FutureStatus::READY)
                return false;
            result = output_;
            return true;
        }
 
    protected:
        const IN& get_input() const
        {
            return input_;
        }
 
        IN& get_input()
        {
            return input_;
        }
 
    private:
        union
        {
            OUT output_;
            uint8_t output_buffer_[sizeof(OUT)];
        };
        union
        {
            IN input_;
            uint8_t input_buffer_[sizeof(IN)];
        };
    };
 
    // Future template specializations for void types
    //================================================
    template<typename OUT_>
    class Future<OUT_, void> : public AbstractFuture
    {
        static_assert(sizeof(OUT_) <= UINT8_MAX, "OUT type must be strictly smaller than 256 bytes");
 
    public:
        using OUT = OUT_;
        using IN = void;
 
        static constexpr uint8_t OUT_SIZE = sizeof(OUT);
        static constexpr uint8_t IN_SIZE = 0;
 
        explicit Future(FutureNotification notifications = FutureNotification::NONE)
        : AbstractFuture{output_buffer_, sizeof(OUT), nullptr, 0, notifications} {}
        ~Future() = default;
 
        // This method completely resets this future (for reuse from scratch)
        void reset_()
        {
            AbstractFuture::reset_(output_buffer_, sizeof(OUT), nullptr, 0);
        }
 
        // The following method is blocking until this Future is ready
        bool get(OUT& result)
        {
            if (await() != FutureStatus::READY)
                return false;
            result = output_;
            return true;
        }
 
    private:
        union
        {
            OUT output_;
            uint8_t output_buffer_[sizeof(OUT)];
        };
    };
 
    template<typename IN_>
    class Future<void, IN_> : public AbstractFuture
    {
        static_assert(sizeof(IN_) <= UINT8_MAX, "IN type must be strictly smaller than 256 bytes");
 
    public:
        using OUT = void;
        using IN = IN_;
 
        static constexpr uint8_t OUT_SIZE = 0;
        static constexpr uint8_t IN_SIZE = sizeof(IN);
 
        explicit Future(const IN& input = IN{}, FutureNotification notifications = FutureNotification::NONE)
            : AbstractFuture{nullptr, 0, input_buffer_, sizeof(IN), notifications}, input_{input} {}
        ~Future() = default;
 
        // This method completely resets this future (for reuse from scratch)
        void reset_(const IN& input = IN{})
        {
            AbstractFuture::reset_(nullptr, 0, input_buffer_, sizeof(IN));
            input_ = input;
        }
 
        bool reset_input_(const IN& input)
        {
            if (!can_replace_input_()) return false;
            input_ = input;
            return true;
        }
 
        // The following method is blocking until this Future is ready
        bool get()
        {
            return (await() == FutureStatus::READY);
        }
 
    protected:
        const IN& get_input() const
        {
            return input_;
        }
        IN& get_input()
        {
            return input_;
        }
 
    private:
        union
        {
            IN input_;
            uint8_t input_buffer_[sizeof(IN)];
        };
    };
 
    template<>
    class Future<void, void> : public AbstractFuture
    {
    public:
        using OUT = void;
        using IN = void;
 
        static constexpr uint8_t OUT_SIZE = 0;
        static constexpr uint8_t IN_SIZE = 0;
 
        explicit Future(FutureNotification notifications = FutureNotification::NONE)
        : AbstractFuture{nullptr, 0,nullptr, 0, notifications} {}
        ~Future() = default;
 
        // This method completely resets this future (for reuse from scratch)
        void reset_()
        {
            AbstractFuture::reset_(nullptr, 0, nullptr, 0);
        }
 
        // The following method is blocking until this Future is ready
        bool get()
        {
            return (await() == FutureStatus::READY);
        }
    };
 
    class AbstractFakeFuture
    {
    public:
        FutureStatus status() const
        {
            return (error_ == 0 ? FutureStatus::READY : FutureStatus::ERROR);
        }
 
        FutureStatus await() const
        {
            return status();
        }
 
        int error() const
        {
            return error_;
        }
 
        // Methods called by a Future consumer
        //=====================================
 
        uint8_t get_storage_value_size_() const
        {
            return input_size_;
        }
 
        bool get_storage_value_(uint8_t& chunk)
        {
            // Check all bytes have not been transferred yet
            chunk = *input_current_++;
            --input_size_;
            return true;
        }
 
        bool get_storage_value_(uint8_t* chunk, uint8_t size)
        {
            memcpy(chunk, input_current_, size);
            input_current_ += size;
            input_size_ -= size;
            return true;
        }
 
        // Methods called by a Future supplier
        //=====================================
 
        uint8_t get_future_value_size_() const
        {
            return output_size_;
        }
 
        bool set_future_finish_()
        {
            callback_status();
            return true;
        }
 
        bool set_future_value_(uint8_t chunk)
        {
            // Update Future value chunk
            *output_current_++ = chunk;
            --output_size_;
            callback_output();
            return true;
        }
 
        bool set_future_value_(const uint8_t* chunk, uint8_t size)
        {
            while (size--)
            {
                set_future_value_(*chunk++);
            }
            return true;
        }
 
        template<typename T> bool set_future_value_(const T& value)
        {
            return set_future_value_(reinterpret_cast<const uint8_t*>(&value), sizeof(T));
        }
 
        bool set_future_error_(int error)
        {
            error_ = error;
            callback_status();
            return true;
        }
 
        
    protected:
        // "default" constructor
        AbstractFakeFuture(uint8_t* output_data, uint8_t output_size, uint8_t* input_data, uint8_t input_size,
            FutureNotification notifications = FutureNotification::NONE)
            :   output_current_{output_data}, output_size_{output_size},
                input_current_{input_data}, input_size_{input_size},
                notifications_{notifications} {}
 
        // these constructors are forbidden (subclass ctors shall call above move/copy ctor instead)
        AbstractFakeFuture(const AbstractFakeFuture&) = delete;
        AbstractFakeFuture& operator=(const AbstractFakeFuture&) = delete;
        AbstractFakeFuture(AbstractFakeFuture&&) = delete;
        AbstractFakeFuture& operator=(AbstractFakeFuture&&) = delete;
 
        ~AbstractFakeFuture() = default;
 
        // This method is called by subclasses to completely reset this future (for reuse from scratch)
        void reset_(uint8_t* output_data, uint8_t output_size, uint8_t* input_data, uint8_t input_size)
        {
            error_ = 0;
            output_current_ = output_data;
            output_size_ = output_size;
            input_current_ = input_data;
            input_size_ = input_size;
        }
 
        // This method is called by subclass to check if input is replaceable,
        // i.e. it has not been read yet
        bool can_replace_input_() const
        {
            return true;
        }
 
    private:
        void callback_status()
        {
            if (uint8_t(notifications_) & uint8_t(FutureNotification::STATUS))
                future_on_status_change_dispatch(*this, status());
        }
        
        void callback_output()
        {
            if (uint8_t(notifications_) & uint8_t(FutureNotification::OUTPUT))
                future_on_output_change_dispatch(*this);
        }
 
        int error_ = 0;
 
        uint8_t* output_current_ = nullptr;
        uint8_t output_size_ = 0;
        
        uint8_t* input_current_ = nullptr;
        uint8_t input_size_ = 0;
 
        FutureNotification notifications_;
 
        template<typename F> friend class AbstractFuturesGroup;
    };
 
    template<typename OUT_ = void, typename IN_ = void>
    class FakeFuture : public AbstractFakeFuture
    {
        static_assert(sizeof(OUT_) <= UINT8_MAX, "OUT type must be strictly smaller than 256 bytes");
        static_assert(sizeof(IN_) <= UINT8_MAX, "IN type must be strictly smaller than 256 bytes");
 
    public:
        using OUT = OUT_;
        using IN = IN_;
 
        static constexpr uint8_t OUT_SIZE = sizeof(OUT);
        static constexpr uint8_t IN_SIZE = sizeof(IN);
 
        explicit FakeFuture(const IN& input = IN{}, 
            FutureNotification notifications = FutureNotification::NONE)
            :   AbstractFakeFuture{output_buffer_, sizeof(OUT), input_buffer_, sizeof(IN),
                notifications}, input_{input} {}
 
        ~FakeFuture() = default;
 
        // This method completely resets this future (for reuse from scratch)
        void reset_(const IN& input = IN{})
        {
            AbstractFakeFuture::reset_(output_buffer_, sizeof(OUT), input_buffer_, sizeof(IN));
            input_ = input;
        }
 
        bool reset_input_(const IN& input)
        {
            input_ = input;
            return true;
        }
 
        bool get(OUT& result)
        {
            result = output_;
            return true;
        }
 
    protected:
        const IN& get_input() const
        {
            return input_;
        }
        IN& get_input()
        {
            return input_;
        }
 
    private:
        union
        {
            OUT output_;
            uint8_t output_buffer_[sizeof(OUT)];
        };
        union
        {
            IN input_;
            uint8_t input_buffer_[sizeof(IN)];
        };
    };
 
    template<typename OUT_>
    class FakeFuture<OUT_, void> : public AbstractFakeFuture
    {
        static_assert(sizeof(OUT_) <= UINT8_MAX, "OUT type must be strictly smaller than 256 bytes");
 
    public:
        using OUT = OUT_;
        using IN = void;
 
        static constexpr uint8_t OUT_SIZE = sizeof(OUT);
        static constexpr uint8_t IN_SIZE = 0;
 
        explicit FakeFuture(FutureNotification notifications = FutureNotification::NONE)
            :   AbstractFakeFuture{output_buffer_, sizeof(OUT), nullptr, 0,
                notifications} {}
 
        ~FakeFuture() = default;
 
        // This method completely resets this future (for reuse from scratch)
        void reset_()
        {
            AbstractFakeFuture::reset_(output_buffer_, sizeof(OUT), nullptr, 0);
        }
 
        bool get(OUT& result)
        {
            result = output_;
            return true;
        }
 
    private:
        union
        {
            OUT output_;
            uint8_t output_buffer_[sizeof(OUT)];
        };
    };
 
    template<typename IN_>
    class FakeFuture<void, IN_> : public AbstractFakeFuture
    {
        static_assert(sizeof(IN_) <= UINT8_MAX, "IN type must be strictly smaller than 256 bytes");
 
    public:
        using OUT = void;
        using IN = IN_;
 
        static constexpr uint8_t OUT_SIZE = 0;
        static constexpr uint8_t IN_SIZE = sizeof(IN);
 
        explicit FakeFuture(const IN& input = IN{}, FutureNotification notifications = FutureNotification::NONE)
            : AbstractFakeFuture{nullptr, 0, input_buffer_, sizeof(IN), notifications}, input_{input} {}
 
        ~FakeFuture() = default;
 
        // This method completely resets this future (for reuse from scratch)
        void reset_(const IN& input = IN{})
        {
            AbstractFakeFuture::reset_(nullptr, 0, input_buffer_, sizeof(IN));
            input_ = input;
        }
 
        bool reset_input_(const IN& input)
        {
            input_ = input;
            return true;
        }
 
        bool get()
        {
            return true;
        }
 
    protected:
        const IN& get_input() const
        {
            return input_;
        }
        IN& get_input()
        {
            return input_;
        }
 
    private:
        union
        {
            IN input_;
            uint8_t input_buffer_[sizeof(IN)];
        };
    };
 
    template<>
    class FakeFuture<void, void> : public AbstractFakeFuture
    {
    public:
        using OUT = void;
        using IN = void;
 
        static constexpr uint8_t OUT_SIZE = 0;
        static constexpr uint8_t IN_SIZE = 0;
 
        explicit FakeFuture(FutureNotification notifications = FutureNotification::NONE)
            : AbstractFakeFuture{nullptr, 0, nullptr, 0, notifications} {}
 
        ~FakeFuture() = default;
 
        void reset_()
        {
            AbstractFakeFuture::reset_(nullptr, 0, nullptr, 0);
        }
 
        bool get()
        {
            return true;
        }
    };
 
    // Specific traits for futures
    template<typename F> struct Future_trait
    {
        static constexpr const bool IS_FUTURE = false;
        static constexpr const bool IS_ABSTRACT = false;
        static constexpr const bool IS_FAKE = false;
    };
    template<> struct Future_trait<AbstractFuture>
    {
        static constexpr const bool IS_FUTURE = true;
        static constexpr const bool IS_ABSTRACT = true;
        static constexpr const bool IS_FAKE = false;
    };
    template<typename OUT, typename IN> struct Future_trait<Future<OUT, IN>>
    {
        static constexpr const bool IS_FUTURE = true;
        static constexpr const bool IS_ABSTRACT = false;
        static constexpr const bool IS_FAKE = false;
    };
    template<> struct Future_trait<AbstractFakeFuture>
    {
        static constexpr const bool IS_FUTURE = true;
        static constexpr const bool IS_ABSTRACT = true;
        static constexpr const bool IS_FAKE = true;
    };
    template<typename OUT, typename IN> struct Future_trait<FakeFuture<OUT, IN>>
    {
        static constexpr const bool IS_FUTURE = true;
        static constexpr const bool IS_ABSTRACT = false;
        static constexpr const bool IS_FAKE = true;
    };
 
    template<typename F> class AbstractFuturesGroup : public F
    {
        static_assert(Future_trait<F>::IS_FUTURE, "F must be a Future");
        static_assert(Future_trait<F>::IS_ABSTRACT, "F must be an abstract Future");
 
    protected:
        static constexpr const uint16_t NO_LIMIT = 0xFFFFU;
        
        explicit AbstractFuturesGroup(FutureNotification notifications = FutureNotification::NONE)
            :   F{nullptr, 0, nullptr, 0, notifications} {}
 
        void init(utils::range<F*> futures, uint16_t actual_size = 0)
        {
            num_ready_ = (actual_size != 0 ? actual_size : futures.size());
            for (F* future: futures)
                future->notifications_ = FutureNotification::STATUS;
        }
 
        void on_status_change_pre_step(const F& future, FutureStatus status)
        {
            switch (status)
            {
                case FutureStatus::ERROR:
                this->set_future_error_(future.error());
                break;
 
                case FutureStatus::INVALID:
                this->set_future_error_(errors::EINVAL);
                break;
 
                case FutureStatus::READY:
                if (--num_ready_ == 0)
                    this->set_future_finish_();
                break;
 
                default:
                break;
            }
        }
 
    private:
        uint16_t num_ready_ = 0;
    };
 
    template<typename F>
    struct dispatch_handler_impl
    {
        template<bool DUMMY> static void future_on_status_change_helper(const F&, FutureStatus)
        {
            // Intentionally blank (last recursive call)
        }
 
        template<bool DUMMY, typename HANDLER1_, typename... HANDLERS_> 
        static void future_on_status_change_helper(const F& future, FutureStatus status)
        {
            HANDLER1_* handler = interrupt::HandlerHolder<HANDLER1_>::handler();
            if (handler != nullptr)
                handler->on_status_change(future, status);
            // handle other handlers
            future_on_status_change_helper<true, HANDLERS_...>(future, status);
        }
 
        template<typename... HANDLERS_>
        static void future_on_status_change(const F& future, FutureStatus status)
        {
            // Ask each registered listener to handle on_status_change() if concerned
            future_on_status_change_helper<true, HANDLERS_...>(future, status);
        }
 
        template<bool DUMMY> static void future_on_output_change_helper(const F&)
        {
            // Intentionally blank (last recursive call)
        }
 
        template<bool DUMMY, typename HANDLER1_, typename... HANDLERS_> 
        static void future_on_output_change_helper(const F& future)
        {
            HANDLER1_* handler = interrupt::HandlerHolder<HANDLER1_>::handler();
            if (handler != nullptr)
                handler->on_output_change(future);
            // handle other handlers
            future_on_output_change_helper<true, HANDLERS_...>(future);
        }
 
        template<typename... HANDLERS_>
        static void future_on_output_change(const F& future)
        {
            // Ask each registered listener to handle on_output_change() if concerned
            future_on_output_change_helper<true, HANDLERS_...>(future);
        }
    };
 
    template<typename F1, typename F2>
    struct dispatch_handler
    {
        template<typename... HANDLERS_>
        static void future_on_status_change(const F2&, FutureStatus)
        {
            // Intentionally blank (tasks performed only on template specialization for actual futures)
        }
        template<typename... HANDLERS_>
        static void future_on_output_change(const F2&)
        {
            // Intentionally blank (tasks performed only on template specialization for actual futures)
        }
    };
 
    template<>
    struct dispatch_handler<AbstractFuture, AbstractFuture>
    {
        template<typename... HANDLERS_>
        static void future_on_status_change(const AbstractFuture& future, FutureStatus status)
        {
            dispatch_handler_impl<AbstractFuture>::future_on_status_change<HANDLERS_...>(
                future, status);
        }
        template<typename... HANDLERS_>
        static void future_on_output_change(const AbstractFuture& future)
        {
            dispatch_handler_impl<AbstractFuture>::future_on_output_change<HANDLERS_...>(future);
        }
    };
 
    template<>
    struct dispatch_handler<AbstractFakeFuture, AbstractFakeFuture>
    {
        template<typename... HANDLERS_>
        static void future_on_status_change(const AbstractFakeFuture& future, FutureStatus status)
        {
            dispatch_handler_impl<AbstractFakeFuture>::future_on_status_change<HANDLERS_...>(
                future, status);
        }
        template<typename... HANDLERS_>
        static void future_on_output_change(const AbstractFakeFuture& future)
        {
            dispatch_handler_impl<AbstractFakeFuture>::future_on_output_change<HANDLERS_...>(future);
        }
    };
}
 
#endif /* FUTURE_HH */