DistributedData.hpp

Go to the documentation of this file.

// -------------------------------------------------------//
//
// SHAMROCK code for hydrodynamics
// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
//
// -------------------------------------------------------//
 
#pragma once
 
#include "shambase/aliases_int.hpp"
#include "shambase/exception.hpp"
#include "shambase/print.hpp"
#include "shambase/sets.hpp"
#include "shambase/string.hpp"
#include <functional>
#include <map>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
 
namespace shambase {
 
    template<class T>
    class DistributedData {
 
        std::map<u64, T> data; 
 
        using iterator = typename std::map<u64, T>::iterator; 
 
        public:
        inline std::map<u64, T> &get_native() { return data; }
 
        inline iterator add_obj(u64 id, T &&obj) {
 
            std::pair<iterator, bool> ret = data.emplace(id, std::forward<T>(obj));
 
            if (!ret.second) {
                throw make_except_with_loc<std::runtime_error>("the key already exist");
            }
 
            return ret.first;
        }
 
        inline void erase(u64 id) { data.erase(id); }
 
        inline void for_each(std::function<void(u64, T &)> &&f) {
            for (auto &[id, obj] : data) {
                f(id, obj);
            }
        }
 
        inline void for_each(std::function<void(u64, const T &)> &&f) const {
            for (auto &[id, obj] : data) {
                f(id, obj);
            }
        }
 
        inline std::vector<u64> get_ids() const {
            std::vector<u64> ids;
            ids.reserve(data.size());
            for (const auto &[id, _] : data) {
                ids.push_back(id);
            }
            return ids;
        }
 
        inline auto find(u64 id) { return data.find(id); }
 
        inline auto not_found() { return data.end(); }
 
        inline T &get(u64 id) {
            try {
                return data.at(id);
            } catch (std::out_of_range &) {
 
                std::vector<u64> id_list;
 
                for_each([&](u64 id, T &) {
                    id_list.push_back(id);
                });
 
                throw make_except_with_loc<std::runtime_error>(shambase::format(
                    "The querried id {} does not exist, current id list is {}", id, id_list));
            }
        }
 
        inline const T &get(u64 id) const {
            try {
                return data.at(id);
            } catch (std::out_of_range &) {
 
                std::vector<u64> id_list;
 
                for_each([&](u64 id, const T &) {
                    id_list.push_back(id);
                });
 
                throw make_except_with_loc<std::runtime_error>(shambase::format(
                    "The querried id {} does not exist, current id list is {}", id, id_list));
            }
        }
 
        inline bool has_key(u64 id) { return (data.find(id) != data.end()); }
 
        inline u64 get_element_count() { return data.size(); }
 
        inline bool is_empty() { return data.empty(); }
 
        template<typename... Tf>
        inline void print_data(fmt::format_string<Tf...> fmt) const {
            for_each([&](u64 id_patch, const T &ref) {
                shambase::println(
                    shambase::format("{} -> {}", id_patch, shambase::format(fmt, ref)));
            });
        }
 
        template<class Tmap>
        inline DistributedData<Tmap> map(std::function<Tmap(u64, T &)> map_func) {
            DistributedData<Tmap> ret;
 
            for_each([&](u64 id, T &ref) {
                ret.add_obj(id, map_func(id, ref));
            });
 
            return ret;
        }
 
        template<class Tmap>
        inline DistributedData<Tmap> map(std::function<Tmap(u64, const T &)> map_func) const {
            DistributedData<Tmap> ret;
 
            for_each([&](u64 id, const T &ref) {
                ret.add_obj(id, map_func(id, ref));
            });
 
            return ret;
        }
 
        inline void reset() { data.clear(); }
    };
 
    template<class T1, class FuncMatch, class FuncMissing, class FuncExtra>
    inline void on_distributeddata_ids_diff(
        const shambase::DistributedData<T1> &dd,
        const std::vector<u64> &ref_ids,
        FuncMatch &&func_missing,
        FuncMissing &&func_match,
        FuncExtra &&func_extra) {
 
        std::vector<u64> dd_ids;
 
        dd.for_each([&](u32 id, const T1 &data) {
            dd_ids.push_back(id);
        });
 
        std::vector<u64> missing;
        std::vector<u64> matching;
        std::vector<u64> extra;
 
        shambase::set_diff(dd_ids, ref_ids, missing, matching, extra);
 
        for (auto id : missing) {
            func_missing(id);
        }
 
        for (auto id : matching) {
            func_match(id);
        }
 
        for (auto id : extra) {
            func_extra(id);
        }
    }
 
    template<class T1, class T2, class FuncMatch, class FuncMissing, class FuncExtra>
    inline void on_distributeddata_diff(
        const shambase::DistributedData<T1> &dd,
        const shambase::DistributedData<T2> &reference,
        FuncMatch &&func_missing,
        FuncMissing &&func_match,
        FuncExtra &&func_extra) {
 
        std::vector<u64> ref_ids;
 
        reference.for_each([&](u32 id, const T2 &data) {
            ref_ids.push_back(id);
        });
 
        shambase::on_distributeddata_ids_diff(dd, ref_ids, func_missing, func_match, func_extra);
    }
 
} // namespace shambase