RecencyTracker.hpp

/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 *
 * Copyright (C) 2025 Marco Craveiro <marco.craveiro@gmail.com>
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation; either version 3 of the License, or (at your option) any later
 * version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 51
 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */
#ifndef ORES_QT_RECENCY_TRACKER_HPP
#define ORES_QT_RECENCY_TRACKER_HPP
 
#include <chrono>
#include <string>
#include <unordered_set>
#include <QDateTime>
#include <ores.platform/attributes.hpp>
 
namespace ores::qt {
 
template<typename Entity>
struct default_timestamp_extractor {
    auto operator()(const Entity& e) const {
        return e.recorded_at;
    }
};
 
template<typename Entity,
         typename KeyExtractor,
         typename TimestampExtractor = default_timestamp_extractor<Entity>>
class RecencyTracker {
public:
    explicit RecencyTracker(KeyExtractor key_extractor)
        : key_extractor_(std::move(key_extractor)),
          timestamp_extractor_() {}
 
    RecencyTracker(KeyExtractor key_extractor, TimestampExtractor timestamp_extractor)
        : key_extractor_(std::move(key_extractor)),
          timestamp_extractor_(std::move(timestamp_extractor)) {}
 
    template<typename Container>
    bool update(const Container& entities) {
        recent_keys_.clear();
 
        const QDateTime now = QDateTime::currentDateTime();
 
        // First load: set baseline timestamp, no highlighting
        if (!last_reload_time_.isValid()) {
            last_reload_time_ = now;
            return false;
        }
 
        // Find entities with recorded_at newer than last reload
        for (const auto& entity : entities) {
            const auto recorded_at = timestamp_extractor_(entity);
            if (recorded_at == std::chrono::system_clock::time_point{}) {
                continue;
            }
 
            const auto msecs = std::chrono::duration_cast<std::chrono::milliseconds>(
                recorded_at.time_since_epoch()).count();
            QDateTime recorded_dt = QDateTime::fromMSecsSinceEpoch(msecs);
 
            if (recorded_dt.isValid() && recorded_dt > last_reload_time_) {
                recent_keys_.insert(key_extractor_(entity));
            }
        }
 
        last_reload_time_ = now;
        return !recent_keys_.empty();
    }
 
    [[nodiscard]] bool is_recent(const std::string& key) const {
        return recent_keys_.find(key) != recent_keys_.end();
    }
 
    [[nodiscard]] std::size_t recent_count() const {
        return recent_keys_.size();
    }
 
    [[nodiscard]] bool has_recent() const {
        return !recent_keys_.empty();
    }
 
    void clear() {
        recent_keys_.clear();
    }
 
    void reset() {
        recent_keys_.clear();
        last_reload_time_ = QDateTime();
    }
 
private:
    KeyExtractor key_extractor_;
    ORES_NO_UNIQUE_ADDRESS TimestampExtractor timestamp_extractor_;
    std::unordered_set<std::string> recent_keys_;
    QDateTime last_reload_time_;
};
 
template<typename Entity, typename KeyExtractor>
auto make_recency_tracker(KeyExtractor key_extractor) {
    return RecencyTracker<Entity, KeyExtractor>(std::move(key_extractor));
}
 
template<typename Entity, typename KeyExtractor, typename TimestampExtractor>
auto make_recency_tracker(KeyExtractor key_extractor,
                          TimestampExtractor timestamp_extractor) {
    return RecencyTracker<Entity, KeyExtractor, TimestampExtractor>(
        std::move(key_extractor), std::move(timestamp_extractor));
}
 
}
 
#endif