immer-utils.hpp

Go to the documentation of this file.

/*
 * This file is part of libkazv.
 * SPDX-FileCopyrightText: 2023 tusooa <tusooa@kazv.moe>
 * SPDX-License-Identifier: AGPL-3.0-or-later
 */
 
#pragma once
#include "libkazv-config.hpp"
 
#include <tuple>
#include <optional>
 
namespace Kazv
{
    template<class T>
    [[nodiscard]] auto getIn(T &&item)
    {
        return std::forward<T>(item);
    }
 
    template<class ImmerT, class K, class ...Keys>
    [[nodiscard]] auto getIn(ImmerT &&container, K &&key, Keys &&...keys)
    {
        return getIn(std::forward<ImmerT>(container)[std::forward<K>(key)], std::forward<Keys>(keys)...);
    }
 
    template<class T>
    [[nodiscard]] auto setIn(T, T newVal)
    {
        return newVal;
    }
 
    template<class ImmerT, class K>
    [[nodiscard]] auto setIn(ImmerT container, std::decay_t<decltype(getIn(std::declval<ImmerT>(), std::declval<K>()))> newVal, K &&key) -> std::decay_t<ImmerT>
    {
        return std::move(container).set(std::forward<K>(key), std::move(newVal));
    }
 
    template<class ImmerT, class K, class ...Keys>
    [[nodiscard]] auto setIn(ImmerT container, std::decay_t<decltype(getIn(std::declval<ImmerT>(), std::declval<K>(), std::declval<Keys>()...))> newVal, K &&key, Keys &&...keys) -> std::decay_t<ImmerT>
    {
        auto oldItem = getIn(container, key);
        return std::move(container).set(
            std::forward<K>(key),
            setIn(oldItem, std::move(newVal), std::forward<Keys>(keys)...)
        );
    }
 
    template<class T, class Func>
    [[nodiscard]] auto updateIn(T oldVal, Func func) -> T
    {
        return std::move(func)(oldVal);
    }
 
    template<class ImmerT, class Func, class ...Keys>
    [[nodiscard]] auto updateIn(ImmerT container, Func func, Keys &&...keys) -> ImmerT
    {
        auto oldVal = getIn(container, keys...);
        auto newVal = std::move(func)(std::move(oldVal));
        return setIn(std::move(container), std::move(newVal), std::forward<Keys>(keys)...);
    }
 
    template<class ImmerT, class Func, class ValueT = typename ImmerT::value_type>
    auto withBox(ImmerT &box, Func &&func) -> std::decay_t<std::invoke_result_t<Func &&, ValueT &>>
    {
        using ResT = std::decay_t<std::invoke_result_t<Func &&, ValueT &>>;
        if constexpr (std::is_same_v<ResT, void>) {
            box = std::move(box)
                .update([f=std::forward<Func>(func)](ValueT v) mutable {
                    std::forward<Func>(f)(v);
                    return v;
                });
        } else {
            std::optional<ResT> res;
            box = std::move(box)
                .update([f=std::forward<Func>(func), &res](ValueT v) mutable {
                    res = std::forward<Func>(f)(v);
                    return v;
                });
            return std::move(res).value();
        }
    }
 
    template<
        class ImmerT,
        class Key,
        class Func,
        class BoxT = typename ImmerT::mapped_type,
        class ValueT = typename BoxT::value_type
        >
    auto withMapBox(ImmerT &map, Key &&k, Func &&func) -> std::decay_t<std::invoke_result_t<Func &&, ValueT &>>
    {
        using ResT = std::decay_t<std::invoke_result_t<Func &&, ValueT &>>;
        if constexpr (std::is_same_v<ResT, void>) {
            map = std::move(map)
                .update(std::forward<Key>(k), [f=std::forward<Func>(func)](BoxT v) mutable {
                    withBox(v, std::forward<Func>(f));
                    return v;
                });
        } else {
            std::optional<ResT> res;
            map = std::move(map)
                .update(std::forward<Key>(k), [f=std::forward<Func>(func), &res](BoxT v) mutable {
                    res = withBox(v, std::forward<Func>(f));
                    return v;
                });
            return std::move(res).value();
        }
    }
}