observable.hpp

/*
 * live_cells_cpp
 * Copyright (C) 2024  Alexander Gutev <alex.gutev@gmail.com>
 *
 * 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 LIVE_CELLS_OBSERVABLE_H
#define LIVE_CELLS_OBSERVABLE_H
 
#include <concepts>
 
#include "keys.hpp"
#include "types.hpp"
 
namespace live_cells {
 
    namespace internal {
 
        struct ref_base {
            virtual ~ref_base() = default;
 
            virtual void add_observer(observer::ref obs) = 0;
            virtual void remove_observer(observer::ref obs) = 0;
 
            virtual key_ref key() const = 0;
        };
 
        template <typename T>
        struct typed_ref_base : ref_base {
            virtual T value() const = 0;
            virtual T operator()() const = 0;
        };
 
        template <typename T>
        struct mutable_cell_ref {
            virtual ~mutable_cell_ref() = default;
            virtual void value(T value) = 0;
        };
 
        template <Cell O>
        struct typed_ref : typed_ref_base<typename O::value_type> {
            O observable;
 
            typed_ref(O obs) : observable(obs) {}
 
            void add_observer(observer::ref obs) override {
                observable.add_observer(obs);
            }
 
            void remove_observer(observer::ref obs) override {
                observable.remove_observer(obs);
            }
 
            key_ref key() const override {
                return observable.key();
            }
 
            typename O::value_type value() const override {
                return observable.value();
            }
 
            typename O::value_type operator()() const override {
                return observable();
            }
        };
 
        template <MutableCell C>
        struct typed_ref<C> : typed_ref_base<typename C::value_type>, mutable_cell_ref<typename C::value_type> {
            C observable;
 
            typed_ref(C obs) : observable(obs) {}
 
            void add_observer(observer::ref obs) override {
                observable.add_observer(obs);
            }
 
            void remove_observer(observer::ref obs) override {
                observable.remove_observer(obs);
            }
 
            key_ref key() const override {
                return observable.key();
            }
 
            typename C::value_type value() const override {
                return observable.value();
            }
 
            void value(typename C::value_type value) override {
                observable.value(value);
            }
 
            typename C::value_type operator()() const override {
                return observable();
            }
        };
 
    }  // internal
 
    template <typename T>
    class typed_cell;
 
    class cell {
    public:
        template <Cell O>
        cell(O o) :
            obs_ref(std::static_pointer_cast<internal::ref_base>(std::make_shared<internal::typed_ref<O>>(o))) {}
 
        template <typename T>
        cell(typed_cell<T> c) :
            obs_ref(std::static_pointer_cast<internal::ref_base>(c.ref)) {
        }
 
        void add_observer(observer::ref obs) {
            obs_ref->add_observer(obs);
        }
 
        void remove_observer(observer::ref obs) {
            obs_ref->remove_observer(obs);
        }
 
        key_ref key() const {
            return obs_ref->key();
        }
 
        template <typename T>
        T value() const {
            auto &base = *obs_ref;
            auto &typed = dynamic_cast<internal::typed_ref_base<T>&>(base);
 
            return typed.value();
        }
 
        template <typename T>
        void value(T value) {
            auto &base = *obs_ref;
            auto &typed = dynamic_cast<internal::mutable_cell_ref<T>&>(base);
 
            typed.value(value);
        }
 
        template <typename T>
        T operator()() const {
            auto &base = *obs_ref;
            auto &typed = dynamic_cast<internal::typed_ref_base<T>&>(base);
 
            return typed();
        }
 
    protected:
 
        std::shared_ptr<internal::ref_base> obs_ref;
 
        template <typename T>
        friend class typed_cell;
    };
 
    struct bad_typed_cell_cast : std::exception {
        const char *what() const noexcept override {
            return "Attempt to cast a `cell` to a `typed_cell<>` with a value type"
                " that is incompatible with the cell's value type.";
        }
    };
 
    template <typename T>
    class typed_cell {
    public:
        template <TypedCell<T> C>
        typed_cell(C cell) :
            ref(std::static_pointer_cast<internal::typed_ref_base<T>>(std::make_shared<internal::typed_ref<C>>(cell))) {
        }
 
        typed_cell(cell c) :
            ref(std::dynamic_pointer_cast<internal::typed_ref_base<T>>(c.obs_ref)) {
 
            if (!ref) {
                throw bad_typed_cell_cast();
            }
        }
 
        void add_observer(observer::ref obs) {
            ref->add_observer(obs);
        }
 
        void remove_observer(observer::ref obs) {
            ref->remove_observer(obs);
        }
 
        key_ref key() const {
            return ref->key();
        }
 
        T value() const {
            return ref->value();
        }
 
        void value(T value) {
            auto &base = *ref;
            auto &typed = dynamic_cast<internal::mutable_cell_ref<T>&>(base);
 
            typed.value(value);
        }
 
        T operator()() const {
            return ref();
        }
 
    private:
        std::shared_ptr<internal::typed_ref_base<T>> ref;
 
        friend class cell;
    };
 
    inline bool operator==(const cell &a, const cell &b) {
        return a.key() == b.key();
    }
 
    inline bool operator!=(const cell &a, const cell &b) {
        return !(a == b);
    }
 
 
    template <typename T1, typename T2>
    inline bool operator==(const typed_cell<T1> &a, const typed_cell<T2> &b) {
        return a.key() == b.key();
    }
 
    template <typename T1, typename T2>
    inline bool operator!=(const typed_cell<T1> &a, const typed_cell<T2> &b) {
        return !(a == b);
    }
 
}  // live_cells
 
 
template<>
struct std::hash<live_cells::cell> {
    std::size_t operator()(const live_cells::cell &a) const noexcept {
        return a.key()->hash();
    }
};
 
template<typename T>
struct std::hash<live_cells::typed_cell<T>> {
    std::size_t operator()(const live_cells::typed_cell<T> &a) const noexcept {
        return a.key()->hash();
    }
};
 
#endif /* LIVE_CELLS_OBSERVABLE_H */