validator.hpp

Go to the documentation of this file.

/*
 * This file is part of libkazv.
 * SPDX-FileCopyrightText: 2020-2023 tusooa <tusooa@kazv.moe>
 * SPDX-License-Identifier: AGPL-3.0-or-later
 */
 
#pragma once
#include <libkazv-config.hpp>
 
#include <functional>
 
#include <types.hpp>
 
namespace Kazv
{
    template<class Jsonish, class Key, class Validator>
    bool cast(Jsonish &ret, const Jsonish &input, Key &&k, Validator &&f)
    {
        if (!input.contains(k)) {
            return false;
        }
        auto [res, output] = std::invoke(std::forward<Validator>(f), input[k]);
        if (!res) {
            return false;
        }
        ret[k] = output;
        return true;
    }
 
    template<class Func>
    auto identValidate(Func &&f)
    {
        return [f=std::forward<Func>(f)](auto &&val) mutable {
            auto res = std::invoke(std::forward<Func>(f), val);
            return std::pair<bool, json>(res, std::forward<decltype(val)>(val));
        };
    }
 
    enum class CastArrayStrategy
    {
        IgnoreInvalid,
        FailAll,
    };
 
    template<class Jsonish, class Key, class Validator>
    bool castArray(Jsonish &ret, const Jsonish &input, Key &&k, Validator &&f, CastArrayStrategy strategy)
    {
        using JsonT = std::decay_t<Jsonish>;
 
        if (!(input.contains(k) && input[k].is_array())) {
            return false;
        }
 
        auto array = JsonT::array();
 
        for (const auto &inputItem : input[k]) {
            auto [res, outputItem] = std::invoke(f, inputItem);
            if (!res) {
                if (strategy == CastArrayStrategy::FailAll) {
                    return false;
                }
            } else {
                array.push_back(std::move(outputItem));
            }
        }
 
        ret[k] = std::move(array);
 
        return true;
    }
 
    enum class CastObjectStrategy
    {
        IgnoreInvalid,
        FailAll,
    };
 
    template<class Jsonish, class Key, class Validator>
    bool castObject(Jsonish &ret, const Jsonish &input, Key &&k, Validator &&f, CastObjectStrategy strategy)
    {
        using JsonT = std::decay_t<Jsonish>;
 
        if (!(input.contains(k) && input[k].is_object())) {
            return false;
        }
 
        auto obj = JsonT::object();
 
        for (const auto &[inputKey, inputValue] : input[k].items()) {
            auto inputItem = JsonT::array({JsonT(inputKey), inputValue});
            auto [res, outputItem] = std::invoke(f, inputItem);
            if (!res) {
                if (strategy == CastObjectStrategy::FailAll) {
                    return false;
                }
            } else {
                auto outputKey = outputItem[0];
                auto outputValue = std::move(outputItem)[1];
                obj[std::move(outputKey)] = std::move(outputValue);
            }
        }
 
        ret[k] = std::move(obj);
 
        return true;
    }
 
    template<class Jsonish, class Key, class Jsonish2>
    std::decay_t<Jsonish> makeDefaultValue(Jsonish &&input, Key &&k, Jsonish2 &&defaultValue)
    {
        using JsonT = std::decay_t<Jsonish>;
 
        if (input.contains(k)) {
            return std::forward<Jsonish>(input);
        } else {
            JsonT output = std::forward<Jsonish>(input);
            output[std::forward<Key>(k)] = std::forward<Jsonish2>(defaultValue);
            return output;
        }
    }
}