tracker.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_TRACKER_HPP
#define LIVE_CELLS_TRACKER_HPP
 
#include <functional>
 
#include "observable.hpp"
 
namespace live_cells {
 
    class argument_tracker {
    public:
        typedef std::function<void(const cell &arg)> track_fn;
 
        template <typename T>
        class tracker {
        public:
            tracker(T fn, argument_tracker &tracker) :
                tracker_(tracker),
                previous(tracker.track_callback) {
                tracker_.track_callback = track_fn(fn);
            }
 
            tracker(const tracker &) = delete;
            tracker(tracker &&other) :
                tracker_(other.tracker_),
                previous(other.previous) {
                other.moved = true;
            }
 
            tracker &operator=(const tracker &) = delete;
            tracker &operator=(tracker &&other) {
                tracker_ = std::move(other.tracker_);
                previous = std::move(other.previous);
            }
 
            ~tracker() {
                if (!moved)
                    tracker_.track_callback = previous;
            }
 
        private:
            argument_tracker &tracker_;
 
            track_fn previous;
 
            bool moved = false;
        };
 
        static argument_tracker& global() {
            return instance_;
        }
 
        argument_tracker(const argument_tracker &other) = delete;
        argument_tracker& operator=(const argument_tracker &other) = delete;
 
        void track_argument(const cell &arg);
 
        template <typename F>
        tracker<F> with_tracker(F track) {
            return tracker<F>(track, *this);
        }
 
    private:
        static argument_tracker instance_;
 
        track_fn track_callback;
 
        argument_tracker() = default;
    };
 
}  // live_cells
 
#endif /* LIVE_CELLS_TRACKER_HPP */