Ichthyostega
7d461adabc
Motivated by the difficulties encountered with `std::apply` — which basically forced us to define our own alternative with conceptually more adequate limitations.... ...so these are the first attempts towards building a C++20 concept.
133 lines
3.8 KiB
C++
133 lines
3.8 KiB
C++
/* try.cpp - to try out and experiment with new features....
|
|
* scons will create the binary bin/try
|
|
*/
|
|
// 06/25 - provide a concept to accept _tuple-like_ objects
|
|
// 06/25 - investigate function type detection of std::bind Binders
|
|
// 12/24 - investigate problem when perfect-forwarding into a binder
|
|
// 12/24 - investigate overload resolution on a templated function similar to std::get
|
|
// 11/24 - how to define a bare object location comparison predicate
|
|
// 11/23 - prototype for grouping from iterator
|
|
|
|
|
|
/** @file try.cpp
|
|
* Develop a concept to detect _tuple-like_ classes, based on the requirements
|
|
* of the »tuple protocol«. Using some ideas from [Stackoverflow] as starting point.
|
|
* [Stackoverflow]: https://stackoverflow.com/q/68443804/444796
|
|
*/
|
|
|
|
|
|
#include "lib/format-cout.hpp"
|
|
#include "lib/test/test-helper.hpp"
|
|
#include "lib/test/diagnostic-output.hpp"
|
|
#include "lib/meta/tuple-helper.hpp"
|
|
#include "lib/hetero-data.hpp"
|
|
#include "lib/util.hpp"
|
|
|
|
#include <concepts>
|
|
|
|
using std::string;
|
|
|
|
namespace lib {
|
|
namespace meta {
|
|
|
|
template<class TUP>
|
|
concept tuple_sized = requires
|
|
{
|
|
{ std::tuple_size<TUP>::value } -> std::convertible_to<size_t>;
|
|
};
|
|
|
|
|
|
template<class TUP, std::size_t N>
|
|
concept tuple_adl_accessible = requires(TUP tup)
|
|
{
|
|
typename std::tuple_element_t<N, TUP>;
|
|
{ get<N>(tup) } -> std::convertible_to<std::tuple_element_t<N, TUP>&>;
|
|
};
|
|
|
|
template<class TUP, std::size_t N>
|
|
concept tuple_mem_accessible = requires(TUP tup)
|
|
{
|
|
typename std::tuple_element_t<N, TUP>;
|
|
{ tup.template get<N>() } -> std::convertible_to<std::tuple_element_t<N, TUP>&>;
|
|
};
|
|
|
|
template<class TUP, std::size_t N>
|
|
concept tuple_accessible = tuple_mem_accessible<TUP,N> or tuple_adl_accessible<TUP,N>;
|
|
|
|
template<class TUP>
|
|
class AndAll
|
|
{
|
|
template<size_t...idx>
|
|
static constexpr bool
|
|
canAccessAll (std::index_sequence<idx...>)
|
|
{
|
|
return (tuple_accessible<TUP, idx> and ...);
|
|
}
|
|
|
|
using IdxSeq = typename ElmTypes<TUP>::Idx;
|
|
|
|
public:
|
|
static constexpr bool can_AccessElement = canAccessAll(IdxSeq{});
|
|
};
|
|
|
|
|
|
template<class TUP>
|
|
concept tuple_like = not is_reference_v<TUP>
|
|
and tuple_sized<remove_cv_t<TUP>>
|
|
and AndAll<remove_cv_t<TUP>>::can_AccessElement;
|
|
|
|
}}//namespace lib::meta
|
|
|
|
|
|
|
|
template<typename X>
|
|
void
|
|
show()
|
|
{
|
|
SHOW_TYPE(X)
|
|
}
|
|
|
|
template<lib::meta::tuple_like X>
|
|
void
|
|
show()
|
|
{
|
|
cout << "Tup!! "<< lib::test::showType<X>() <<endl;
|
|
lib::meta::forEachIDX<X> ([](auto i)
|
|
{
|
|
using Elm = std::tuple_element_t<i, X>;
|
|
cout <<" "<<uint(i)<<": "<< lib::test::showType<Elm>() <<endl;
|
|
});
|
|
}
|
|
|
|
|
|
int
|
|
main (int, char**)
|
|
{
|
|
using Tup = std::tuple<long>;
|
|
using Arr = std::array<int,3>;
|
|
using Hetero = lib::HeteroData<int,string>::Chain<short>::ChainExtent<bool,lib::meta::Nil>::ChainType;
|
|
|
|
SHOW_EXPR((lib::meta::tuple_sized<Tup> ))
|
|
SHOW_EXPR((lib::meta::tuple_sized<Arr> ))
|
|
SHOW_EXPR((lib::meta::tuple_sized<Hetero> ))
|
|
SHOW_EXPR((lib::meta::tuple_sized<int> ))
|
|
|
|
SHOW_EXPR((lib::meta::tuple_accessible<Tup,0>))
|
|
// SHOW_EXPR((lib::meta::tuple_accessible<Tup,2>))
|
|
SHOW_EXPR((lib::meta::tuple_accessible<Hetero,0>))
|
|
SHOW_EXPR((lib::meta::AndAll<Tup>::can_AccessElement))
|
|
SHOW_EXPR((lib::meta::AndAll<Hetero>::can_AccessElement))
|
|
|
|
SHOW_EXPR((lib::meta::tuple_like<Tup> ))
|
|
SHOW_EXPR((lib::meta::tuple_like<Arr> ))
|
|
SHOW_EXPR((lib::meta::tuple_like<Hetero> ))
|
|
SHOW_EXPR((lib::meta::tuple_like<int> ))
|
|
|
|
show<Tup>();
|
|
show<Arr>();
|
|
show<Hetero>();
|
|
show<int>();
|
|
|
|
cout << "\n.gulp." <<endl;
|
|
return 0;
|
|
}
|