parse_reply.hpp

Go to the documentation of this file.

#pragma once
 
/// @file
/// @brief Customizations for Redis response parsings
 
#include <concepts>
#include <optional>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#include <userver/formats/json/value.hpp>
#include <userver/storages/redis/fwd.hpp>
 
#include <userver/storages/redis/hexpiretime_reply.hpp>
#include <userver/storages/redis/hpexpiretime_reply.hpp>
#include <userver/storages/redis/pttl_reply.hpp>
#include <userver/storages/redis/reply_types.hpp>
#include <userver/storages/redis/ttl_reply.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace storages::redis {
namespace impl {
 
ReplyData&& ExtractData(ReplyPtr& reply);
 
template <typename Result, typename ReplyType = Result>
concept HasParseFunctionFromRedisReply = requires {
    {
        Result::Parse(std::declval<ReplyData>(), std::declval<const std::string&>())
    } -> std::same_as<ReplyType>;
};
 
bool IsNil(const ReplyData& reply_data);
 
void ExpectIsOk(const ReplyPtr& reply, const std::string& request_description);
 
void ExpectArray(const ReplyData& reply_data, const std::string& request_description);
 
const std::string& RequestDescription(const ReplyPtr& reply, const std::string& request_description);
 
}  // namespace impl
 
/// An ADL helper that allows searching for `Parse` functions in namespace
/// `storages::redis` additionally to the namespace of `Result`.
template <typename Result, typename ReplyType = Result>
struct To {};
 
std::vector<std::string>
ParseReplyDataArray(ReplyData&& array_data, const std::string& request_description, To<std::vector<std::string>>);
 
std::vector<int64_t>
ParseReplyDataArray(ReplyData&& array_data, const std::string& request_description, To<std::vector<int64_t>>);
 
std::
    vector<std::optional<std::string>>
    ParseReplyDataArray(ReplyData&& array_data, const std::string& request_description, To<std::vector<std::optional<std::string>>>);
 
std::vector<std::pair<std::string, std::string>>
ParseReplyDataArray(ReplyData&& array_data, const std::string& request_description, To<std::vector<std::pair<std::string, std::string>>>);
 
std::vector<MemberScore>
ParseReplyDataArray(ReplyData&& array_data, const std::string& request_description, To<std::vector<MemberScore>>);
 
std::vector<GeoPoint>
ParseReplyDataArray(ReplyData&& array_data, const std::string& request_description, To<std::vector<GeoPoint>>);
 
std::vector<HexpireReply>
ParseReplyDataArray(ReplyData&& array_data, const std::string& request_description, To<std::vector<HexpireReply>>);
 
std::vector<HpersistReply>
ParseReplyDataArray(ReplyData&& array_data, const std::string& request_description, To<std::vector<HpersistReply>>);
 
std::vector<TtlReply>
ParseReplyDataArray(ReplyData&& array_data, const std::string& request_description, To<std::vector<TtlReply>>);
 
std::vector<PttlReply>
ParseReplyDataArray(ReplyData&& array_data, const std::string& request_description, To<std::vector<PttlReply>>);
 
std::vector<HexpiretimeReply>
ParseReplyDataArray(ReplyData&& array_data, const std::string& request_description, To<std::vector<HexpiretimeReply>>);
 
std::vector<HpexpiretimeReply>
ParseReplyDataArray(ReplyData&& array_data, const std::string& request_description, To<std::vector<HpexpiretimeReply>>);
 
std::
    vector<std::optional<Point>>
    ParseReplyDataArray(ReplyData&& array_data, const std::string& request_description, To<std::vector<std::optional<Point>>>);
 
std::string Parse(ReplyData&& reply_data, const std::string& request_description, To<std::string>);
 
double Parse(ReplyData&& reply_data, const std::string& request_description, To<double>);
 
size_t Parse(ReplyData&& reply_data, const std::string& request_description, To<size_t>);
 
bool Parse(ReplyData&& reply_data, const std::string& request_description, To<size_t, bool>);
 
int64_t Parse(ReplyData&& reply_data, const std::string& request_description, To<int64_t>);
 
std::chrono::system_clock::time_point
Parse(ReplyData&& reply_data, const std::string& request_description, To<std::chrono::system_clock::time_point>);
 
HsetReply Parse(ReplyData&& reply_data, const std::string& request_description, To<HsetReply>);
 
HsetexReply Parse(ReplyData&& reply_data, const std::string& request_description, To<HsetexReply>);
 
PersistReply Parse(ReplyData&& reply_data, const std::string& request_description, To<PersistReply>);
 
HexpireReply Parse(ReplyData&& reply_data, const std::string& request_description, To<HexpireReply>);
 
HpersistReply Parse(ReplyData&& reply_data, const std::string& request_description, To<HpersistReply>);
 
KeyType Parse(ReplyData&& reply_data, const std::string& request_description, To<KeyType>);
 
void Parse(ReplyData&& reply_data, const std::string& request_description, To<StatusOk, void>);
 
bool Parse(ReplyData&& reply_data, const std::string& request_description, To<std::optional<StatusOk>, bool>);
 
void Parse(ReplyData&& reply_data, const std::string& request_description, To<StatusPong, void>);
 
Point Parse(ReplyData&& reply_data, const std::string& request_description, To<Point>);
 
SetReply Parse(ReplyData&& reply_data, const std::string& request_description, To<SetReply>);
 
std::unordered_set<std::string>
Parse(ReplyData&& reply_data, const std::string& request_description, To<std::unordered_set<std::string>>);
 
std::unordered_map<std::string, std::string>
Parse(ReplyData&& reply_data, const std::string& request_description, To<std::unordered_map<std::string, std::string>>);
 
ReplyData Parse(ReplyData&& reply_data, const std::string& request_description, To<ReplyData>);
 
formats::json::Value Parse(ReplyData&& reply_data, const std::string& request_description, To<formats::json::Value>);
 
std::vector<std::optional<formats::json::Value>>
ParseReplyDataArray(ReplyData&& array_data, const std::string& request_description, To<std::vector<std::optional<formats::json::Value>>>);
 
template <typename Result, typename ReplyType = Result>
requires impl::HasParseFunctionFromRedisReply<Result, ReplyType>
ReplyType Parse(ReplyData&& reply_data, const std::string& request_description, To<Result, ReplyType>) {
    return Result::Parse(std::move(reply_data), request_description);
}
 
template <typename T>
std::vector<T> Parse(ReplyData&& reply_data, const std::string& request_description, To<std::vector<T>>) {
    impl::ExpectArray(reply_data, request_description);
    return ParseReplyDataArray(std::move(reply_data), request_description, To<std::vector<T>>{});
}
 
template <typename T>
std::optional<T> Parse(ReplyData&& reply_data, const std::string& request_description, To<std::optional<T>>) {
    if (impl::IsNil(reply_data)) {
        return std::nullopt;
    }
    return Parse(std::move(reply_data), request_description, To<T>{});
}
 
namespace impl {
 
template <typename Result, typename ReplyType = Result>
ReplyType ParseReply(ReplyPtr reply, const std::string& request_description = {}) {
    const auto& description = impl::RequestDescription(reply, request_description);
    impl::ExpectIsOk(reply, description);
    return Parse(impl::ExtractData(reply), description, To<Result, ReplyType>{});  // Customization point
}
 
}  // namespace impl
 
}  // namespace storages::redis
 
USERVER_NAMESPACE_END