mirror of
https://github.com/matrix-construct/construct
synced 2024-12-28 00:14:07 +01:00
114 lines
3.2 KiB
C++
114 lines
3.2 KiB
C++
// Matrix Construct
|
|
//
|
|
// Copyright (C) Matrix Construct Developers, Authors & Contributors
|
|
// Copyright (C) 2016-2019 Jason Volk <jason@zemos.net>
|
|
//
|
|
// Permission to use, copy, modify, and/or distribute this software for any
|
|
// purpose with or without fee is hereby granted, provided that the above
|
|
// copyright notice and this permission notice is present in all copies. The
|
|
// full license for this software is available in the LICENSE file.
|
|
|
|
#pragma once
|
|
#define HAVE_IRCD_M_QUERY_H
|
|
|
|
namespace ircd::m
|
|
{
|
|
template<class R, class F> R query(std::nothrow_t, const event::idx &, const string_view &key, R&& def, F&&);
|
|
template<class F> auto query(std::nothrow_t, const event::idx &, const string_view &key, F&&);
|
|
|
|
template<class R, class F> R query(const event::idx &, const string_view &key, R&& def, F&&);
|
|
template<class F> auto query(const event::idx &, const string_view &key, F&&);
|
|
}
|
|
|
|
/// Like m::get(), but the closure returns a value which will then be returned
|
|
/// by these functions. This elides the pattern of returning a result through
|
|
/// the lambda capture when one simply wants to condition on the fetched value
|
|
/// rather than make further use of it.
|
|
///
|
|
template<class F>
|
|
inline auto
|
|
ircd::m::query(const event::idx &event_idx,
|
|
const string_view &key,
|
|
F&& closure)
|
|
{
|
|
using R = typename std::invoke_result<F, const string_view &>::type;
|
|
|
|
R ret;
|
|
m::get(event_idx, key, [&ret, &closure]
|
|
(const string_view &value)
|
|
noexcept(std::is_nothrow_invocable<F, decltype(value)>())
|
|
{
|
|
ret = closure(value);
|
|
});
|
|
|
|
return ret;
|
|
}
|
|
|
|
template<class R,
|
|
class F>
|
|
inline R
|
|
ircd::m::query(const event::idx &event_idx,
|
|
const string_view &key,
|
|
R&& r,
|
|
F&& f)
|
|
{
|
|
return query(std::nothrow, event_idx, key, std::forward<R>(r), std::forward<F>(f));
|
|
}
|
|
|
|
/// See other overload documentation first. This overload implements
|
|
/// non-throwing behavior when the event_idx/key(column) is not found by
|
|
/// calling the closure with a default-constructed string so the closure can
|
|
/// return a default value.
|
|
///
|
|
template<class F>
|
|
inline auto
|
|
ircd::m::query(std::nothrow_t,
|
|
const event::idx &event_idx,
|
|
const string_view &key,
|
|
F&& closure)
|
|
{
|
|
using R = typename std::invoke_result<F, const string_view &>::type;
|
|
|
|
R ret;
|
|
const auto assign
|
|
{
|
|
[&ret, &closure](const string_view &value)
|
|
noexcept(std::is_nothrow_invocable<F, decltype(value)>())
|
|
{
|
|
ret = closure(value);
|
|
}
|
|
};
|
|
|
|
if(unlikely(!m::get(std::nothrow, event_idx, key, assign)))
|
|
assign(string_view{});
|
|
|
|
return ret;
|
|
}
|
|
|
|
/// See other overload documentation first. This overload implements
|
|
/// non-throwing behavior when the event_idx/key(column) is not found by
|
|
/// returning a default value supplied by the caller.
|
|
///
|
|
template<class R,
|
|
class F>
|
|
inline R
|
|
ircd::m::query(std::nothrow_t,
|
|
const event::idx &event_idx,
|
|
const string_view &key,
|
|
R&& default_,
|
|
F&& closure)
|
|
{
|
|
R ret
|
|
{
|
|
std::forward<R>(default_)
|
|
};
|
|
|
|
m::get(std::nothrow, event_idx, key, [&ret, &closure]
|
|
(const string_view &value)
|
|
noexcept(std::is_nothrow_invocable<F, decltype(value)>())
|
|
{
|
|
ret = closure(value);
|
|
});
|
|
|
|
return ret;
|
|
}
|