Modifiers.hpp

#pragma once
 
#include "rpc/Errors.hpp"
#include "rpc/common/Types.hpp"
#include "util/JsonUtils.hpp"
 
#include <boost/json/value.hpp>
#include <boost/json/value_to.hpp>
#include <xrpl/protocol/ErrorCodes.h>
 
#include <concepts>
#include <exception>
#include <functional>
#include <string>
#include <string_view>
 
namespace rpc::modifiers {

template <typename Type>
class Clamp final {
    Type min_;
    Type max_;
 
public:
    explicit Clamp(Type min, Type max) : min_{min}, max_{max}
    {
    }

    [[nodiscard]] MaybeError
    modify(boost::json::value& value, std::string_view key) const
    {
        using boost::json::value_to;
 
        if (not value.is_object() or not value.as_object().contains(key))
            return {};  // ignore. field does not exist, let 'required' fail instead
 
        // clamp to min_ and max_
        auto const oldValue = value_to<Type>(value.as_object().at(key));
        value.as_object()[key] = std::clamp<Type>(oldValue, min_, max_);
 
        return {};
    }
};

struct ToLower final {
    [[nodiscard]] static MaybeError
    modify(boost::json::value& value, std::string_view key)
    {
        if (not value.is_object() or not value.as_object().contains(key))
            return {};  // ignore. field does not exist, let 'required' fail instead
 
        if (not value.as_object().at(key).is_string())
            return {};  // ignore for non-string types
 
        value.as_object()[key] =
            util::toLower(boost::json::value_to<std::string>(value.as_object().at(key)));
        return {};
    }
};

struct ToNumber final {
    [[nodiscard]] static MaybeError
    modify(boost::json::value& value, std::string_view key)
    {
        if (not value.is_object() or not value.as_object().contains(key))
            return {};  // ignore. field does not exist, let 'required' fail instead
 
        if (not value.as_object().at(key).is_string())
            return {};  // ignore for non-string types
 
        auto const strInt = boost::json::value_to<std::string>(value.as_object().at(key));
        if (strInt.find('.') != std::string::npos)
            return Error{Status{RippledError::rpcINVALID_PARAMS}};  // maybe a float
 
        try {
            value.as_object()[key] = std::stoi(strInt);
        } catch (std::exception& e) {
            return Error{Status{RippledError::rpcINVALID_PARAMS}};
        }
        return {};
    }
};

class CustomModifier final {
    std::function<MaybeError(boost::json::value&, std::string_view)> modifier_;
 
public:
    template <typename Fn>
        requires std::invocable<Fn, boost::json::value&, std::string_view>
    explicit CustomModifier(Fn&& fn) : modifier_{std::forward<Fn>(fn)}
    {
    }

    [[nodiscard]] MaybeError
    modify(boost::json::value& value, std::string_view key) const
    {
        if (not value.is_object() or not value.as_object().contains(key))
            return {};  // ignore. field does not exist, let 'required' fail instead
 
        return modifier_(value.as_object().at(key), key);
    };
};
 
}  // namespace rpc::modifiers