previous_value_cell.hpp

#ifndef LIVE_CELLS_PREVIOUS_VALUE_CELL_HPP
#define LIVE_CELLS_PREVIOUS_VALUE_CELL_HPP
 
#include "keys.hpp"
#include "stateful_cell.hpp"
#include "cell_state.hpp"
#include "observer_cell_state.hpp"
#include "maybe.hpp"
#include "exceptions.hpp"
 
namespace live_cells {
 
    template <typename T>
    struct previous_value_cell_key : value_key<T> {
        using value_key<T>::value_key;
    };
 
    template <Cell C>
    class previous_value_cell_state : public cell_state, public observer, public observer_cell_state {
        typedef typename C::value_type value_type;
 
    public:
        previous_value_cell_state(key_ref k, C cell) :
            cell_state(k),
            cell(cell),
 
            current_value(maybe<value_type>::wrap([cell] {
                return cell.value();
            })) {
 
            stale = false;
        }
 
        value_type value() {
            if (stale) {
                update_current_value();
            }
 
            return prev_value.unwrap();
        }
 
    protected:
        void init() override {
            cell_state::init();
            init_observer_state();
 
            cell.add_observer(observer_ptr());
 
            current_value = maybe<value_type>::wrap([this] {
                return cell.value();
            });
        }
 
        void pause() override {
            cell.remove_observer(observer_ptr());
 
            prev_value = maybe<value_type>();
            current_value = maybe<value_type>();
 
            cell_state::pause();
            pause_observer_state();
        }
 
        void will_update(const key_ref &k) override {
            handle_will_update([this] {
                notify_will_update();
            });
        }
 
        void update(const key_ref &k, bool changed) override {
            handle_update(
                changed,
                [] { return true; },
 
                [this] (bool changed) {
                    if (stale) {
                        update_current_value();
                    }
 
                    notify_update(changed);
                },
 
                [] {}
            );
        }
 
    private:
        const C cell;
 
        maybe<value_type> prev_value;
 
        maybe<value_type> current_value;
 
        std::shared_ptr<observer> observer_ptr() {
            return std::dynamic_pointer_cast<observer>(this->shared_from_this());
        }
 
        void update_current_value() {
            auto next_value = maybe<value_type>::wrap([this] {
                return cell.value();
            });
 
            if (current_value == next_value) {
                stale = false;
                return;
            }
 
            prev_value = current_value;
            current_value = next_value;
 
            stale = false;
        }
    };
 
    template <Cell C>
    class previous_value_cell : public stateful_cell<previous_value_cell_state<C>> {
 
        typedef stateful_cell<previous_value_cell_state<C>> parent;
 
        typedef previous_value_cell_key<key_ref> key_type;
 
    public:
        typedef typename C::value_type value_type;
 
        previous_value_cell(const C &cell) :
            parent(key_ref::create<key_type>(cell.key()), cell),
            cell(cell) {}
 
        value_type value() const {
            return this->state->value();
        }
 
        value_type operator()() const {
            argument_tracker::global().track_argument(*this);
            return value();
        }
 
    private:
 
        const C cell;
    };
 
    template <Cell C>
    auto previous(const C &cell) {
        return previous_value_cell<C>(cell);
    }
 
    namespace ops {
        constexpr auto previous = [] (const Cell auto &cell) {
            return live_cells::previous(cell);
        };
 
    }  // ops
 
}  // live_cells
 
#endif /* LIVE_CELLS_PREVIOUS_VALUE_CELL_HPP */