libcruft-util/signal.hpp

/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * Copyright 2011-2019 Danny Robson <danny@nerdcruft.net>
 */

#pragma once

#include "types/traits.hpp"
#include "debug.hpp"
#include "nocopy.hpp"

#include <algorithm>
#include <functional>
#include <list>

namespace cruft {
    namespace reduce {
        template <typename FunctionT>
        struct logical_and {
            using result = typename func_traits<FunctionT>::return_type;

            template <typename InputT, typename ...Args>
            result operator() (InputT first, InputT last, Args&&... args)
            {
                while (first != last)
                    if (!(*first++)(args...))
                        return false;

                return true;
            }
        };

        template <typename FunctionT>
        struct logical_or {
            using result = typename func_traits<FunctionT>::return_type;

            template <typename InputT, typename ...Args>
            result operator() (InputT first, InputT last, Args&&... args)
            {
                while (first != last)
                    if ((*first++)(args...))
                        return true;

                return false;
            }
        };

        template <typename FunctionT>
        struct noop {
            using result = void;

            template <typename InputT, typename ...Args>
            result operator() (InputT first, InputT last, Args&&... args)
            {
                while (first != last) {
                    (*first++)(args...);
                }
            }
        };
    }

    template <
        typename FunctionT,
        template <typename> class ReductionT = reduce::noop
    >
    class signal {
        public:
            using result = typename ReductionT<FunctionT>::result;
            using callback = std::function<FunctionT>;

            struct cookie;

        public:
            signal () = default;
            ~signal ()
            {
                CHECK (empty ());
            }

            /// Add a callback to list.
            cookie connect [[nodiscard]] (callback &&_cb)
            {
                return cookie (
                    m_children.insert (
                        m_children.end (),
                        std::move (_cb)
                    ),
                    *this
                );
            }

            cookie connect [[nodiscard]] (const callback &_cb)
            {
                {
                    return cookie (
                        m_children.insert (
                            m_children.end (),
                            std::move (_cb)
                        ),
                        *this
                    );
                }
            }

            void disconnect (cookie &c)
            {
                m_children.erase (c.m_position);
                c.m_position = m_children.end ();
            }

            /// Disconnect all callbacks
            void clear (void)
            {
                m_children.clear ();
            }

            /// Returns the number of callbacks connected.
            size_t size (void) const
            {
                return m_children.size ();
            }

            bool empty (void) const
            {
                return m_children.empty ();
            }

            /// Execute all callbacks
            template <typename ...ArgsT>
            result
            operator() (ArgsT&&... tail)
            {
                if (m_children.empty ())
                    return result();

                ReductionT<FunctionT> reducer;
                return reducer (
                    m_children.begin (),
                    m_children.end (),
                    std::forward<ArgsT> (tail)...
                );
            }

        private:
            typedef std::list<callback> group;
            group m_children;
    };


    ///////////////////////////////////////////////////////////////////////////
    template <typename FunctionT, template <typename> class ReductionT>
    struct signal<FunctionT,ReductionT>::cookie : public nocopy {
        cookie (typename group::iterator _position,
                signal<FunctionT,ReductionT> &_parent):
            m_position (_position),
            m_parent (_parent)
        { ; }

        cookie (cookie &&rhs):
            m_position (rhs.m_position),
            m_parent (rhs.m_parent)
        {
            rhs.m_position = rhs.m_parent.m_children.end ();
        }

        ~cookie ()
        {
            if (m_parent.m_children.end () != m_position)
                m_parent.disconnect (*this);
        }

        void reset (callback &&cb)
        {
            *m_position = std::move (cb);
        }

        typename group::iterator m_position;
        signal<FunctionT,ReductionT> &m_parent;
    };



    ///////////////////////////////////////////////////////////////////////////
    // wrap a value in a signal and trigger on assignment
    //template <typename T, template <typename> class ReductionT>
    template <typename ValueT>
    class value_signal : public signal<void(ValueT)> {
    public:
        explicit value_signal (ValueT _value): m_value (_value) { ; }
        value_signal () = default;

        operator const ValueT&() const { return m_value; }

        value_signal<ValueT>&
        operator= (const ValueT &t)
        {
            m_value = t;
            (*this) (m_value);
            return *this;
        }

    private:
        ValueT m_value;
    };
}