// ccutl.arg feature guard {{{
#ifndef CCUTL_ARG_INCLUDED
#define CCUTL_ARG_INCLUDED
// ccutl.arg feature guard }}}
/* C++20
| |
__| __| | | __| |
( ( | | | |
\___| \___| \__,_| \__| _|
ccutl Core Utilities
[ccutl.arg]: returns the passed arg by index, preserving reference qualifier
Copyright (C) 2020, 2021 Justin Collier
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the internalied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>. */
#include <type_traits>
#ifndef CCUTL_NAMESPACE
#define CCUTL_NAMESPACE ctl
#endif
namespace CCUTL_NAMESPACE {
// ccutl.rmref {{{
// ccutl.rmref feature guard {{{
#ifndef CCUTL_RMREF_INCLUDED
#define CCUTL_RMREF_INCLUDED
// ccutl.rmref feature guard }}}
/**
* shorthand for std::remove_reference_t
*
* \anchor rmref
* \ingroup ccutl
*/
template <class T>
using rmref = std::remove_reference_t<T>;
// ccutl.rmref version guard {{{
#define CCUTL_RMREF_VERSION_MAJOR 0
#define CCUTL_RMREF_VERSION_MINOR 3
#define CCUTL_RMREF_VERSION_PATCH 2
#elif CCUTL_RMREF_VERSION_MAJOR != 0
#error ccutl.rmref major version mismatch
#elif CCUTL_RMREF_VERSION_MINOR != 3
#error ccutl.rmref minor version mismatch
#elif CCUTL_RMREF_VERSION_PATCH != 2
#warning ccutl.rmref patch version mismatch
#endif
// ccutl.rmref version guard }}}
// ccutl.rmref }}}
// ccutl.fwd {{{
// ccutl.fwd feature guard {{{
#ifndef CCUTL_FWD_INCLUDED
#define CCUTL_FWD_INCLUDED
// ccutl.fwd feature guard }}}
/*
note: the following was copied from the C++ standard draft GitHub sources
https://github.com/cplusplus/draft.git 60a9591
©ISO/IEC
20.2.4 forward/move helpers [forward]
1 The library provides templated helper functions to simplify applying move
semantics to an lvalue and to simplify the implementation of forwarding
functions. All functions specified in this subclause are signal-safe
(17.13.4).
template <class T> constexpr T&& forward(remove_reference_t<T>& t) noexcept;
template <class T> constexpr T&& forward(remove_reference_t<T>&& t) noexcept;
2 Mandates: For the second overload, is_lvalue_reference_v<T> is false.
3 Returns: static_cast<T&&>(t).
*/
/**
* perfect forwarder for lvalues
*
* \anchor fwd
* \ingroup ccutl
*/
template <class T>
constexpr T&&
fwd(rmref<T>& t) noexcept {
return static_cast<T&&>(t);
}
/**
* perfect forwarder for rvalues
*
* \anchor fwd
* \ingroup ccutl
*/
template <class T>
constexpr T&&
fwd(rmref<T>&& t) noexcept {
static_assert(
!std::is_lvalue_reference_v<T>,
"cannot instantiate an rvalue forwarder with an lvalue reference type");
return static_cast<T&&>(t);
}
// ccutl.fwd version guard {{{
#define CCUTL_FWD_VERSION_MAJOR 0
#define CCUTL_FWD_VERSION_MINOR 3
#define CCUTL_FWD_VERSION_PATCH 2
#elif CCUTL_FWD_VERSION_MAJOR != 0
#error ccutl.fwd major version mismatch
#elif CCUTL_FWD_VERSION_MINOR != 3
#error ccutl.fwd minor version mismatch
#elif CCUTL_FWD_VERSION_PATCH != 2
#warning ccutl.fwd patch version mismatch
#endif
// ccutl.fwd version guard }}}
// ccutl.fwd }}}
/* */ // clang-format off
// detail {{{
namespace detail {
namespace arg {
/// lvalue forwarder for final arg result
template <std::size_t targ, std::size_t i, class First, class... Rest>
requires (targ == i) && (std::is_lvalue_reference_v<First &&>)
[[nodiscard]] inline constexpr First &
impl(First&& first, Rest &&...) noexcept {
return fwd<First>(first);
}
/// rvalue forwarder for final arg result
template <std::size_t targ, std::size_t i, class First, class... Rest>
requires (targ == i) && (std::is_rvalue_reference_v<First &&>)
[[nodiscard]] inline constexpr First &&
impl(First&& first, Rest &&...) noexcept {
return fwd<First>(first);
}
/// recursively pop_front arguments until incrementation is completed
template <std::size_t targ, std::size_t i, class First, class... Rest>
requires (targ != i)
[[nodiscard]] inline constexpr auto &&
impl(First &&, Rest &&... rest) noexcept {
return impl<targ, i + 1>(fwd<Rest>(rest)...);
}
/// checks if idx is within range to be able to index Ts
template <std::size_t idx, class... Ts>
inline constexpr bool
valid_indexable_pack = sizeof...(Ts) > 0 && idx < sizeof...(Ts);
} // namespace arg
} // namespace detail
// detail }}}
/**
* returns the passed arg by index, preserving reference qualifier
*
* \code
* #include "ctl/arg.h"
*
* char c = 'c';
* auto &&x0 = ctl::arg<0>('a', "b", c); // (char) 'a'
* auto &&x1 = ctl::arg<1>('a', "b", c); // (char const*) "b"
* auto &&x2 = ctl::arg<2>('a', "b", c); // (char &) c
* \endcode
*
* \anchor arg
* \ingroup ccutl
*/
template <std::size_t idx, class... Ts>
requires detail::arg::valid_indexable_pack<idx, Ts...>
[[nodiscard]] inline constexpr auto &&
arg(Ts &&... args) noexcept {
return detail::arg::impl<idx, 0>(fwd<Ts>(args)...);
}
/* */ // clang-format on
} // namespace CCUTL_NAMESPACE
// ccutl.arg version guard {{{
#define CCUTL_ARG_VERSION_MAJOR 0
#define CCUTL_ARG_VERSION_MINOR 3
#define CCUTL_ARG_VERSION_PATCH 2
#elif CCUTL_ARG_VERSION_MAJOR != 0
#error ccutl.arg major version mismatch
#elif CCUTL_ARG_VERSION_MINOR != 3
#error ccutl.arg minor version mismatch
#elif CCUTL_ARG_VERSION_PATCH != 2
#warning ccutl.arg patch version mismatch
#endif
// vim: fmr={{{,}}} fdm=marker
// ccutl.arg version guard }}}