Add cmake code to generate c++ meta functions to check for class members

CMakeModules/check_for_member/method.in.h

+// This file is generated using cmake configure_file!
+
+#pragma once
+
+#include <type_traits>
+
+//implementation namespace
+namespace simox::meta::member::method::@NAME@::impl
+{
+    template<class Class, class RType, class...Ps>
+    RType type_fn(RType(Class::*)(Ps...));
+    template<class T>
+    using ret_t = decltype(type_fn(&T::@NAME@));
+
+    template<class T, class = void>
+    struct member_rtype {};
+    template<class T>
+    struct member_rtype<T, std::void_t<ret_t<T>>>
+    {
+        using type = ret_t<T>;
+    };
+
+    template<class T, class = void>
+    struct member_exists : std::false_type {};
+    template<class T>
+    struct member_exists<T, std::void_t<ret_t<T>>> : std::true_type {};
+}
+
+//meta fncs namespaced by class
+namespace simox::meta::member::method::@NAME@
+{
+    template<class T> using exists                   = impl::member_exists<T>;
+    template<class T> static constexpr bool exists_v = exists<T>::value;
+    template<class T> using return_type              = impl::member_rtype<T>;
+    template<class T> using return_type_t            = typename return_type<T>::type;
+}
+
+//exists_v
+namespace simox::meta::member::method::exists_v
+{
+    template<class T>
+    static constexpr bool @NAME@ = ::simox::meta::member::method::@NAME@::exists_v<T>;
+}
+//concept
+namespace simox::meta::member::method::ccept
+{
+    template<class T>
+    concept @NAME@ = ::simox::meta::member::method::@NAME@::exists_v<T>;
+}
+//return_type_t
+namespace simox::meta::member::method::return_type_t
+{
+    template<class T>
+    using @NAME@ = simox::meta::member::method::@NAME@::return_type_t<T>;
+}

CMakeModules/check_for_member/static_method.in.h

+// This file is generated using cmake configure_file!
+
+#pragma once
+
+#include <type_traits>
+
+//implementation namespace
+namespace simox::meta::member::static_method::@NAME@::impl
+{
+    template<class RType, class...Ps>
+    RType type_fn(RType(*)(Ps...));
+    template<class T>
+    using ret_t = decltype(type_fn(&T::@NAME@));
+
+    template<class T, class = void>
+    struct member_rtype {};
+    template<class T>
+    struct member_rtype<T, std::void_t<ret_t<T>>>
+    {
+        using type = ret_t<T>;
+    };
+
+    template<class T, class = void>
+    struct member_exists : std::false_type {};
+    template<class T>
+    struct member_exists<T, std::void_t<ret_t<T>>> : std::true_type {};
+}
+
+//meta fncs namespaced by class
+namespace simox::meta::member::static_method::@NAME@
+{
+    template<class T> using exists                   = impl::member_exists<T>;
+    template<class T> static constexpr bool exists_v = exists<T>::value;
+    template<class T> using return_type              = impl::member_rtype<T>;
+    template<class T> using return_type_t            = typename return_type<T>::type;
+}
+
+//exists_v
+namespace simox::meta::member::static_method::exists_v
+{
+    template<class T>
+    static constexpr bool @NAME@ = ::simox::meta::member::static_method::@NAME@::exists_v<T>;
+}
+//concept
+namespace simox::meta::member::static_method::ccept
+{
+    template<class T>
+    concept @NAME@ = ::simox::meta::member::static_method::@NAME@::exists_v<T>;
+}
+//return_type_t
+namespace simox::meta::member::static_method::return_type_t
+{
+    template<class T>
+    using @NAME@ = simox::meta::member::static_method::@NAME@::return_type_t<T>;
+}

CMakeModules/check_for_member/static_variable.in.h

+// This file is generated using cmake configure_file!
+
+#pragma once
+
+#include <type_traits>
+
+//implementation namespace
+namespace simox::meta::member::static_variable::@NAME@::impl
+{
+    template<class Type>
+    Type type_fn(const Type*);
+    template<class T>
+    using var_t = decltype(type_fn(&T::@NAME@));
+    
+    template<class T, class = void>
+    struct member_value_type {};
+    template<class T>
+    struct member_value_type<T, std::void_t<var_t<T>>>
+    {
+        using type = var_t<T>;
+    };
+
+    template<class T, class = void>
+    struct member_value_exists : std::false_type {};
+    template<class T>
+    struct member_value_exists<T, std::void_t<var_t<T>>> : std::true_type {};
+}
+
+//meta fncs namespaced by class
+namespace simox::meta::member::static_variable::@NAME@
+{
+    template<class T> using exists                   = impl::member_value_exists<T>;
+    template<class T> static constexpr bool exists_v = exists<T>::value;
+    template<class T> using type                     = impl::member_value_type<T>;
+    template<class T> using type_t                   = typename type<T>::type;
+}
+
+//exists_v
+namespace simox::meta::member::static_variable::exists_v
+{
+    template<class T>
+    static constexpr bool @NAME@ = ::simox::meta::member::static_variable::@NAME@::exists_v<T>;
+}
+//concept
+namespace simox::meta::member::static_variable::ccept
+{
+    template<class T>
+    concept @NAME@ = ::simox::meta::member::static_variable::@NAME@::exists_v<T>;
+}
+//type_t
+namespace simox::meta::member::static_variable::type_t
+{
+    template<class T>
+    using @NAME@ = ::simox::meta::member::static_variable::@NAME@::type_t<T>;
+}

CMakeModules/check_for_member/test.in.cpp

+// This file is generated using cmake configure_file!
+
+#define BOOST_TEST_MODULE SimoxUtility/meta/check_for_members_@CATEGORY@_@NAME@
+
+#include <boost/test/included/unit_test.hpp>
+
+#include <SimoxUtility/meta/type_traits/member/method/@NAME@.h>
+#include <SimoxUtility/meta/type_traits/member/static_method/@NAME@.h>
+#include <SimoxUtility/meta/type_traits/member/variable/@NAME@.h>
+#include <SimoxUtility/meta/type_traits/member/static_variable/@NAME@.h>
+#include <SimoxUtility/meta/type_traits/member/type/@NAME@.h>
+// ////////////////////////////////////////////////////////////////////////// //
+//test stub
+// *INDENT-OFF*
+template<class T, class Texp, bool Exists> struct test_method          { static void test(); };
+template<class T, class Texp, bool Exists> struct test_static_method   { static void test(); };
+template<class T, class Texp, bool Exists> struct test_variable        { static void test(); };
+template<class T, class Texp, bool Exists> struct test_static_variable { static void test(); };
+template<class T, class Texp, bool Exists> struct test_type            { static void test(); };
+// *INDENT-ON*
+// ////////////////////////////////////////////////////////////////////////// //
+//core test function
+template<class T, class Texp, bool Exists>
+void test_method<T, Texp, Exists>::test()
+{
+    namespace ns = simox::meta::member::method;
+    static_assert(Exists == ns::exists_v::@NAME@<T>);
+    static_assert(Exists == ns::ccept   ::@NAME@<T>);
+    if constexpr(Exists)
+    {
+        static_assert(std::is_same_v < Texp, ns::return_type_t::@NAME@<T >>);
+    }
+}
+template<class T, class Texp, bool Exists>
+void test_static_method<T, Texp, Exists>::test()
+{
+    namespace ns = simox::meta::member::static_method;
+    static_assert(Exists == ns::exists_v::@NAME@<T>);
+    static_assert(Exists == ns::ccept   ::@NAME@<T>);
+    if constexpr(Exists)
+    {
+        static_assert(std::is_same_v < Texp, ns::return_type_t::@NAME@<T >>);
+    }
+}
+template<class T, class Texp, bool Exists>
+void test_variable<T, Texp, Exists>::test()
+{
+    namespace ns = simox::meta::member::variable;
+    static_assert(Exists == ns::exists_v::@NAME@<T>);
+    static_assert(Exists == ns::ccept   ::@NAME@<T>);
+    if constexpr(Exists)
+    {
+        static_assert(std::is_same_v < Texp, ns::type_t::@NAME@<T >>);
+    }
+}
+template<class T, class Texp, bool Exists>
+void test_static_variable<T, Texp, Exists>::test()
+{
+    namespace ns = simox::meta::member::static_variable;
+    static_assert(Exists == ns::exists_v::@NAME@<T>);
+    static_assert(Exists == ns::ccept   ::@NAME@<T>);
+    if constexpr(Exists)
+    {
+        static_assert(std::is_same_v < Texp, ns::type_t::@NAME@<T >>);
+    }
+}
+template<class T, class Texp, bool Exists>
+void test_type<T, Texp, Exists>::test()
+{
+    namespace ns = simox::meta::member::type;
+    static_assert(Exists == ns::exists_v::@NAME@<T>);
+    static_assert(Exists == ns::ccept   ::@NAME@<T>);
+    if constexpr(Exists)
+    {
+        static_assert(std::is_same_v < Texp, ns::type_t::@NAME@<T >>);
+    }
+}
+
+// ////////////////////////////////////////////////////////////////////////// //
+// default impl
+class nonprimitive {};
+
+// *INDENT-OFF*
+template<class T> struct with_variable           {                  T @NAME@   = {}; };
+template<class T> struct with_variable_2         {                  T @NAME@_2 = {}; };
+
+template<class T> struct with_static_variable    { static constexpr T @NAME@   = {}; };
+template<class T> struct with_static_variable_2  { static constexpr T @NAME@_2 = {}; };
+
+template<class T> struct with_type               {              using @NAME@   = T;  };
+template<class T> struct with_type_2             {              using @NAME@_2 = T;  };
+
+template<class T> struct with_method             {                  T @NAME@  ();    };
+template<class T> struct with_method_2           {                  T @NAME@_2();    };
+
+template<class T> struct with_static_method      {           static T @NAME@  ();    };
+template<class T> struct with_static_method_2    {           static T @NAME@_2();    };
+// *INDENT-ON*
+
+enum member_type
+{
+    variable, static_variable,
+    method, static_method,
+    type,
+};
+
+template<template<class, class, bool> class Tmp, class T, member_type MT>
+void test_all_for_type()
+{
+    Tmp<with_static_variable  <T>, T, MT == member_type::static_variable>::test();
+    Tmp<with_static_variable_2<T>, T, false                             >::test();
+
+    Tmp<with_variable         <T>, T, MT == member_type::variable       >::test();
+    Tmp<with_variable_2       <T>, T, false                             >::test();
+
+    Tmp<with_type             <T>, T, MT == member_type::type           >::test();
+    Tmp<with_type_2           <T>, T, false                             >::test();
+
+    Tmp<with_method           <T>, T, MT == member_type::method         >::test();
+    Tmp<with_method_2         <T>, T, false                             >::test();
+
+    Tmp<with_static_method    <T>, T, MT == member_type::static_method  >::test();
+    Tmp<with_static_method_2  <T>, T, false                             >::test();
+}
+
+template<class T>
+void test_all()
+{
+    test_all_for_type<test_method,          T, member_type::method         >();
+    test_all_for_type<test_static_method,   T, member_type::static_method  >();
+    test_all_for_type<test_variable,        T, member_type::variable       >();
+    test_all_for_type<test_static_variable, T, member_type::static_variable>();
+    test_all_for_type<test_type,            T, member_type::type           >();
+}
+
+BOOST_AUTO_TEST_CASE(test_check_for_members_@NAME@)
+{
+    test_all <int         > ();
+    test_all <nonprimitive> ();
+}

CMakeModules/check_for_member/type.in.h

+// This file is generated using cmake configure_file!
+
+#pragma once
+
+#include <type_traits>
+
+//implementation namespace
+namespace simox::meta::member::type::@NAME@::impl
+{
+    template<class T, class = void>
+    struct member_type_exists : std::false_type
+    {};
+    template<class T>
+    struct member_type_exists < T, std::void_t < typename T::@NAME@ > > : std::true_type
+    {};
+
+    template<class T, class = void>
+    struct member_type_type
+    {};
+
+    template<class T>
+    struct member_type_type < T, std::void_t < typename T::@NAME@ > >
+    {
+        using type = typename T::@NAME@;
+    };
+}
+
+//meta fncs namespaced by class
+namespace simox::meta::member::type::@NAME@
+{
+    template<class T> using exists                   = impl::member_type_exists<T>;
+    template<class T> static constexpr bool exists_v = exists<T>::value;
+    template<class T> using type                     = impl::member_type_type<T>;
+    template<class T> using type_t                   = typename type<T>::type;
+}
+
+//exists_v
+namespace simox::meta::member::type::exists_v
+{
+    template<class T>
+    static constexpr bool @NAME@ = ::simox::meta::member::type::@NAME@::exists_v<T>;
+}
+//concept
+namespace simox::meta::member::type::ccept
+{
+    template<class T>
+    concept @NAME@ = ::simox::meta::member::type::@NAME@::exists_v<T>;
+}
+//type_t
+namespace simox::meta::member::type::type_t
+{
+    template<class T>
+    using @NAME@ = ::simox::meta::member::type::@NAME@::type_t<T>;
+}

CMakeModules/check_for_member/variable.in.h

+// This file is generated using cmake configure_file!
+
+#pragma once
+
+#include <type_traits>
+
+//implementation namespace
+namespace simox::meta::member::variable::@NAME@::impl
+{
+    template<class Class, class Type>
+    Type type_fn(Type Class::*);
+    template<class T>
+    using var_t = decltype(type_fn(&T::@NAME@));
+
+    template<class T, class = void>
+    struct member_type {};
+    template<class T>
+    struct member_type<T, std::void_t<var_t<T>>>
+    {
+        using type = var_t<T>;
+    };
+
+    template<class T, class = void>
+    struct member_exists : std::false_type {};
+    template<class T>
+    struct member_exists<T, std::void_t<var_t<T>>> : std::true_type {};
+}
+
+//meta fncs namespaced by class
+namespace simox::meta::member::variable::@NAME@
+{
+    template<class T> using exists                   = impl::member_exists<T>;
+    template<class T> static constexpr bool exists_v = exists<T>::value;
+    template<class T> using type                     = impl::member_type<T>;
+    template<class T> using type_t                   = typename type<T>::type;
+}
+
+//exists_v
+namespace simox::meta::member::variable::exists_v
+{
+    template<class T>
+    static constexpr bool @NAME@ = ::simox::meta::member::variable::@NAME@::exists_v<T>;
+}
+//concept
+namespace simox::meta::member::variable::ccept
+{
+    template<class T>
+    concept @NAME@ = ::simox::meta::member::variable::@NAME@::exists_v<T>;
+}
+//type_t
+namespace simox::meta::member::variable::type_t
+{
+    template<class T>
+    using @NAME@ = simox::meta::member::variable::@NAME@::type_t<T>;
+}

SimoxUtility/CMakeLists.txt

@@ -260,12 +260,66 @@ SET(INCLUDES
     threads/CountingSemaphore.h
 )
 
+##########################################################################################################
+#################################### generate meta functions ##################################
+
+macro(make_check_for_member)
+    macro(make_check_for_member_sub category name)
+        set(targrel meta/type_traits/member/${category}/${name}.h)
+        set(ofile ${CMAKE_CURRENT_LIST_DIR}/${targrel})
+        set(ifile ${CMAKE_SOURCE_DIR}/CMakeModules/check_for_member/${category}.in.h)
+        set(NAME ${name})
+        configure_file(${ifile} ${ofile} @ONLY)
+        list(APPEND INCLUDES ${targrel})
+    endmacro()
+    set(GEN_CHECK_MEMBER_META_CODE_KEYWORDS ${ARGN})
+    list(REMOVE_DUPLICATES GEN_CHECK_MEMBER_META_CODE_KEYWORDS)
+    set(GEN_CHECK_MEMBER_META_CODE_CATEGORIES
+        method static_method
+        variable static_variable
+        type
+    )
+    foreach(v ${GEN_CHECK_MEMBER_META_CODE_KEYWORDS})
+        foreach(c ${GEN_CHECK_MEMBER_META_CODE_CATEGORIES})
+            make_check_for_member_sub(${c} ${v})
+        endforeach()
+    endforeach()
+endmacro()
+make_check_for_member(
+    #terator
+    begin end cbegin cend
+    #container
+    size empty reserve clear resize
+    emplace_back emplace_front emplace
+    push_back push_front
+    insert
+    at front back data
+    #point members (wh sometimes are homogeneous coords)
+    point vertex x y z w h _0 _1 _2
+    #quat members
+    qx qy qz qw
+    #points members
+    vertices points
+    #other
+    value val npos
+    value_t value_type size_type size_t iterator
+    first second
+    exact extract str string c_str swap
+    min max
+)
+
+
+##########################################################################################################
+#################################### generate_subdir_headers ##################################
 simox_generate_subdir_headers(
     ${CMAKE_CURRENT_LIST_DIR}
     ${CMAKE_CURRENT_LIST_DIR}
     INCLUDES
 )
 
+##########################################################################################################
+##########################################################################################################
+##########################################################################################################
 if(BUILD_TESTING)
     # include unit tests
     ADD_SUBDIRECTORY(tests)

SimoxUtility/meta/type_traits.h

@@ -6,3 +6,4 @@
 #include "type_traits/is_any_of.h"
 #include "type_traits/is_std_array.h"
 #include "type_traits/is_string_like.h"
+#include "type_traits/member.h"

SimoxUtility/meta/type_traits/member.h

+#pragma once
+
+// This file is generated!
+
+#include "member/method.h"
+#include "member/static_method.h"
+#include "member/static_variable.h"
+#include "member/type.h"
+#include "member/value.h"
+#include "member/variable.h"

SimoxUtility/meta/type_traits/member/method.h

+#pragma once
+
+// This file is generated!
+
+#include "method/_0.h"
+#include "method/_1.h"
+#include "method/_2.h"
+#include "method/at.h"
+#include "method/back.h"
+#include "method/begin.h"
+#include "method/c_str.h"
+#include "method/cbegin.h"
+#include "method/cend.h"
+#include "method/clear.h"
+#include "method/data.h"
+#include "method/emplace.h"
+#include "method/emplace_back.h"
+#include "method/emplace_front.h"
+#include "method/empty.h"
+#include "method/end.h"
+#include "method/exact.h"
+#include "method/extract.h"
+#include "method/first.h"
+#include "method/front.h"
+#include "method/h.h"
+#include "method/insert.h"
+#include "method/iterator.h"
+#include "method/max.h"
+#include "method/min.h"
+#include "method/npos.h"
+#include "method/point.h"
+#include "method/points.h"
+#include "method/push_back.h"
+#include "method/push_front.h"
+#include "method/qw.h"
+#include "method/qx.h"
+#include "method/qy.h"
+#include "method/qz.h"
+#include "method/reserve.h"
+#include "method/resize.h"
+#include "method/second.h"
+#include "method/size.h"
+#include "method/size_t.h"
+#include "method/size_type.h"
+#include "method/str.h"
+#include "method/string.h"
+#include "method/swap.h"
+#include "method/val.h"
+#include "method/value.h"
+#include "method/value_t.h"
+#include "method/value_type.h"
+#include "method/vertex.h"
+#include "method/vertices.h"
+#include "method/w.h"
+#include "method/x.h"
+#include "method/y.h"
+#include "method/z.h"

SimoxUtility/meta/type_traits/member/method/_0.h

+// This file is generated using cmake configure_file!
+
+#pragma once
+
+#include <type_traits>
+
+//implementation namespace
+namespace simox::meta::member::method::_0::impl
+{
+    template<class Class, class RType, class...Ps>
+    RType type_fn(RType(Class::*)(Ps...));
+    template<class T>
+    using ret_t = decltype(type_fn(&T::_0));
+
+    template<class T, class = void>
+    struct member_rtype {};
+    template<class T>
+    struct member_rtype<T, std::void_t<ret_t<T>>>
+    {
+        using type = ret_t<T>;
+    };
+
+    template<class T, class = void>
+    struct member_exists : std::false_type {};
+    template<class T>
+    struct member_exists<T, std::void_t<ret_t<T>>> : std::true_type {};
+}
+
+//meta fncs namespaced by class
+namespace simox::meta::member::method::_0
+{
+    template<class T> using exists                   = impl::member_exists<T>;
+    template<class T> static constexpr bool exists_v = exists<T>::value;
+    template<class T> using return_type              = impl::member_rtype<T>;
+    template<class T> using return_type_t            = typename return_type<T>::type;
+}
+
+//exists_v
+namespace simox::meta::member::method::exists_v
+{
+    template<class T>
+    static constexpr bool _0 = ::simox::meta::member::method::_0::exists_v<T>;
+}
+//concept
+namespace simox::meta::member::method::ccept
+{
+    template<class T>
+    concept _0 = ::simox::meta::member::method::_0::exists_v<T>;
+}
+//return_type_t
+namespace simox::meta::member::method::return_type_t
+{
+    template<class T>
+    using _0 = simox::meta::member::method::_0::return_type_t<T>;
+}

SimoxUtility/meta/type_traits/member/method/_1.h

+// This file is generated using cmake configure_file!
+
+#pragma once
+
+#include <type_traits>
+
+//implementation namespace
+namespace simox::meta::member::method::_1::impl
+{
+    template<class Class, class RType, class...Ps>
+    RType type_fn(RType(Class::*)(Ps...));
+    template<class T>
+    using ret_t = decltype(type_fn(&T::_1));
+
+    template<class T, class = void>
+    struct member_rtype {};
+    template<class T>
+    struct member_rtype<T, std::void_t<ret_t<T>>>
+    {
+        using type = ret_t<T>;
+    };
+
+    template<class T, class = void>
+    struct member_exists : std::false_type {};
+    template<class T>
+    struct member_exists<T, std::void_t<ret_t<T>>> : std::true_type {};
+}
+
+//meta fncs namespaced by class
+namespace simox::meta::member::method::_1
+{
+    template<class T> using exists                   = impl::member_exists<T>;
+    template<class T> static constexpr bool exists_v = exists<T>::value;
+    template<class T> using return_type              = impl::member_rtype<T>;
+    template<class T> using return_type_t            = typename return_type<T>::type;
+}
+
+//exists_v
+namespace simox::meta::member::method::exists_v
+{
+    template<class T>
+    static constexpr bool _1 = ::simox::meta::member::method::_1::exists_v<T>;
+}
+//concept
+namespace simox::meta::member::method::ccept
+{
+    template<class T>
+    concept _1 = ::simox::meta::member::method::_1::exists_v<T>;
+}
+//return_type_t
+namespace simox::meta::member::method::return_type_t
+{
+    template<class T>
+    using _1 = simox::meta::member::method::_1::return_type_t<T>;
+}

SimoxUtility/meta/type_traits/member/method/_2.h

+// This file is generated using cmake configure_file!
+
+#pragma once
+
+#include <type_traits>
+
+//implementation namespace
+namespace simox::meta::member::method::_2::impl
+{
+    template<class Class, class RType, class...Ps>
+    RType type_fn(RType(Class::*)(Ps...));
+    template<class T>
+    using ret_t = decltype(type_fn(&T::_2));
+
+    template<class T, class = void>
+    struct member_rtype {};
+    template<class T>
+    struct member_rtype<T, std::void_t<ret_t<T>>>
+    {
+        using type = ret_t<T>;
+    };
+
+    template<class T, class = void>
+    struct member_exists : std::false_type {};
+    template<class T>
+    struct member_exists<T, std::void_t<ret_t<T>>> : std::true_type {};
+}
+
+//meta fncs namespaced by class
+namespace simox::meta::member::method::_2
+{
+    template<class T> using exists                   = impl::member_exists<T>;
+    template<class T> static constexpr bool exists_v = exists<T>::value;
+    template<class T> using return_type              = impl::member_rtype<T>;
+    template<class T> using return_type_t            = typename return_type<T>::type;
+}
+
+//exists_v
+namespace simox::meta::member::method::exists_v
+{
+    template<class T>
+    static constexpr bool _2 = ::simox::meta::member::method::_2::exists_v<T>;
+}
+//concept
+namespace simox::meta::member::method::ccept
+{
+    template<class T>
+    concept _2 = ::simox::meta::member::method::_2::exists_v<T>;
+}
+//return_type_t
+namespace simox::meta::member::method::return_type_t
+{
+    template<class T>
+    using _2 = simox::meta::member::method::_2::return_type_t<T>;
+}

SimoxUtility/meta/type_traits/member/method/at.h

+// This file is generated using cmake configure_file!
+
+#pragma once
+
+#include <type_traits>
+
+//implementation namespace
+namespace simox::meta::member::method::at::impl
+{
+    template<class Class, class RType, class...Ps>
+    RType type_fn(RType(Class::*)(Ps...));
+    template<class T>
+    using ret_t = decltype(type_fn(&T::at));
+
+    template<class T, class = void>
+    struct member_rtype {};
+    template<class T>
+    struct member_rtype<T, std::void_t<ret_t<T>>>
+    {
+        using type = ret_t<T>;
+    };
+
+    template<class T, class = void>
+    struct member_exists : std::false_type {};
+    template<class T>
+    struct member_exists<T, std::void_t<ret_t<T>>> : std::true_type {};
+}
+
+//meta fncs namespaced by class
+namespace simox::meta::member::method::at
+{
+    template<class T> using exists                   = impl::member_exists<T>;
+    template<class T> static constexpr bool exists_v = exists<T>::value;
+    template<class T> using return_type              = impl::member_rtype<T>;
+    template<class T> using return_type_t            = typename return_type<T>::type;
+}
+
+//exists_v
+namespace simox::meta::member::method::exists_v
+{
+    template<class T>
+    static constexpr bool at = ::simox::meta::member::method::at::exists_v<T>;
+}
+//concept
+namespace simox::meta::member::method::ccept
+{
+    template<class T>
+    concept at = ::simox::meta::member::method::at::exists_v<T>;
+}
+//return_type_t
+namespace simox::meta::member::method::return_type_t
+{
+    template<class T>
+    using at = simox::meta::member::method::at::return_type_t<T>;
+}

SimoxUtility/meta/type_traits/member/method/back.h

+// This file is generated using cmake configure_file!
+
+#pragma once
+
+#include <type_traits>
+
+//implementation namespace
+namespace simox::meta::member::method::back::impl
+{
+    template<class Class, class RType, class...Ps>
+    RType type_fn(RType(Class::*)(Ps...));
+    template<class T>
+    using ret_t = decltype(type_fn(&T::back));
+
+    template<class T, class = void>
+    struct member_rtype {};
+    template<class T>
+    struct member_rtype<T, std::void_t<ret_t<T>>>
+    {
+        using type = ret_t<T>;
+    };
+
+    template<class T, class = void>
+    struct member_exists : std::false_type {};
+    template<class T>
+    struct member_exists<T, std::void_t<ret_t<T>>> : std::true_type {};
+}
+
+//meta fncs namespaced by class
+namespace simox::meta::member::method::back
+{
+    template<class T> using exists                   = impl::member_exists<T>;
+    template<class T> static constexpr bool exists_v = exists<T>::value;
+    template<class T> using return_type              = impl::member_rtype<T>;
+    template<class T> using return_type_t            = typename return_type<T>::type;
+}
+
+//exists_v
+namespace simox::meta::member::method::exists_v
+{
+    template<class T>
+    static constexpr bool back = ::simox::meta::member::method::back::exists_v<T>;
+}
+//concept
+namespace simox::meta::member::method::ccept
+{
+    template<class T>
+    concept back = ::simox::meta::member::method::back::exists_v<T>;
+}
+//return_type_t
+namespace simox::meta::member::method::return_type_t
+{
+    template<class T>
+    using back = simox::meta::member::method::back::return_type_t<T>;
+}

SimoxUtility/meta/type_traits/member/method/begin.h

+// This file is generated using cmake configure_file!
+
+#pragma once
+
+#include <type_traits>
+
+//implementation namespace
+namespace simox::meta::member::method::begin::impl
+{
+    template<class Class, class RType, class...Ps>
+    RType type_fn(RType(Class::*)(Ps...));
+    template<class T>
+    using ret_t = decltype(type_fn(&T::begin));
+
+    template<class T, class = void>
+    struct member_rtype {};
+    template<class T>
+    struct member_rtype<T, std::void_t<ret_t<T>>>
+    {
+        using type = ret_t<T>;
+    };
+
+    template<class T, class = void>
+    struct member_exists : std::false_type {};
+    template<class T>
+    struct member_exists<T, std::void_t<ret_t<T>>> : std::true_type {};
+}
+
+//meta fncs namespaced by class
+namespace simox::meta::member::method::begin
+{
+    template<class T> using exists                   = impl::member_exists<T>;
+    template<class T> static constexpr bool exists_v = exists<T>::value;
+    template<class T> using return_type              = impl::member_rtype<T>;
+    template<class T> using return_type_t            = typename return_type<T>::type;
+}
+
+//exists_v
+namespace simox::meta::member::method::exists_v
+{
+    template<class T>
+    static constexpr bool begin = ::simox::meta::member::method::begin::exists_v<T>;
+}
+//concept
+namespace simox::meta::member::method::ccept
+{
+    template<class T>
+    concept begin = ::simox::meta::member::method::begin::exists_v<T>;
+}
+//return_type_t
+namespace simox::meta::member::method::return_type_t
+{
+    template<class T>
+    using begin = simox::meta::member::method::begin::return_type_t<T>;
+}

SimoxUtility/meta/type_traits/member/method/c_str.h

+// This file is generated using cmake configure_file!
+
+#pragma once
+
+#include <type_traits>
+
+//implementation namespace
+namespace simox::meta::member::method::c_str::impl
+{
+    template<class Class, class RType, class...Ps>
+    RType type_fn(RType(Class::*)(Ps...));
+    template<class T>
+    using ret_t = decltype(type_fn(&T::c_str));
+
+    template<class T, class = void>
+    struct member_rtype {};
+    template<class T>
+    struct member_rtype<T, std::void_t<ret_t<T>>>
+    {
+        using type = ret_t<T>;
+    };
+
+    template<class T, class = void>
+    struct member_exists : std::false_type {};
+    template<class T>
+    struct member_exists<T, std::void_t<ret_t<T>>> : std::true_type {};
+}
+
+//meta fncs namespaced by class
+namespace simox::meta::member::method::c_str
+{
+    template<class T> using exists                   = impl::member_exists<T>;
+    template<class T> static constexpr bool exists_v = exists<T>::value;
+    template<class T> using return_type              = impl::member_rtype<T>;
+    template<class T> using return_type_t            = typename return_type<T>::type;
+}
+
+//exists_v
+namespace simox::meta::member::method::exists_v
+{
+    template<class T>
+    static constexpr bool c_str = ::simox::meta::member::method::c_str::exists_v<T>;
+}
+//concept
+namespace simox::meta::member::method::ccept
+{
+    template<class T>
+    concept c_str = ::simox::meta::member::method::c_str::exists_v<T>;
+}
+//return_type_t
+namespace simox::meta::member::method::return_type_t
+{
+    template<class T>
+    using c_str = simox::meta::member::method::c_str::return_type_t<T>;
+}

SimoxUtility/meta/type_traits/member/method/cbegin.h

+// This file is generated using cmake configure_file!
+
+#pragma once
+
+#include <type_traits>
+
+//implementation namespace
+namespace simox::meta::member::method::cbegin::impl
+{
+    template<class Class, class RType, class...Ps>
+    RType type_fn(RType(Class::*)(Ps...));
+    template<class T>
+    using ret_t = decltype(type_fn(&T::cbegin));
+
+    template<class T, class = void>
+    struct member_rtype {};
+    template<class T>
+    struct member_rtype<T, std::void_t<ret_t<T>>>
+    {
+        using type = ret_t<T>;
+    };
+
+    template<class T, class = void>
+    struct member_exists : std::false_type {};
+    template<class T>
+    struct member_exists<T, std::void_t<ret_t<T>>> : std::true_type {};
+}
+
+//meta fncs namespaced by class
+namespace simox::meta::member::method::cbegin
+{
+    template<class T> using exists                   = impl::member_exists<T>;
+    template<class T> static constexpr bool exists_v = exists<T>::value;
+    template<class T> using return_type              = impl::member_rtype<T>;
+    template<class T> using return_type_t            = typename return_type<T>::type;
+}
+
+//exists_v
+namespace simox::meta::member::method::exists_v
+{
+    template<class T>
+    static constexpr bool cbegin = ::simox::meta::member::method::cbegin::exists_v<T>;
+}
+//concept
+namespace simox::meta::member::method::ccept
+{
+    template<class T>
+    concept cbegin = ::simox::meta::member::method::cbegin::exists_v<T>;
+}
+//return_type_t
+namespace simox::meta::member::method::return_type_t
+{
+    template<class T>
+    using cbegin = simox::meta::member::method::cbegin::return_type_t<T>;
+}

SimoxUtility/meta/type_traits/member/method/cend.h

+// This file is generated using cmake configure_file!
+
+#pragma once
+
+#include <type_traits>
+
+//implementation namespace
+namespace simox::meta::member::method::cend::impl
+{
+    template<class Class, class RType, class...Ps>
+    RType type_fn(RType(Class::*)(Ps...));
+    template<class T>
+    using ret_t = decltype(type_fn(&T::cend));
+
+    template<class T, class = void>
+    struct member_rtype {};
+    template<class T>
+    struct member_rtype<T, std::void_t<ret_t<T>>>
+    {
+        using type = ret_t<T>;
+    };
+
+    template<class T, class = void>
+    struct member_exists : std::false_type {};
+    template<class T>
+    struct member_exists<T, std::void_t<ret_t<T>>> : std::true_type {};
+}
+
+//meta fncs namespaced by class
+namespace simox::meta::member::method::cend
+{
+    template<class T> using exists                   = impl::member_exists<T>;
+    template<class T> static constexpr bool exists_v = exists<T>::value;
+    template<class T> using return_type              = impl::member_rtype<T>;
+    template<class T> using return_type_t            = typename return_type<T>::type;
+}
+
+//exists_v
+namespace simox::meta::member::method::exists_v
+{
+    template<class T>
+    static constexpr bool cend = ::simox::meta::member::method::cend::exists_v<T>;
+}
+//concept
+namespace simox::meta::member::method::ccept
+{
+    template<class T>
+    concept cend = ::simox::meta::member::method::cend::exists_v<T>;
+}
+//return_type_t
+namespace simox::meta::member::method::return_type_t
+{
+    template<class T>
+    using cend = simox::meta::member::method::cend::return_type_t<T>;
+}

SimoxUtility/meta/type_traits/member/method/clear.h

+// This file is generated using cmake configure_file!
+
+#pragma once
+
+#include <type_traits>
+
+//implementation namespace
+namespace simox::meta::member::method::clear::impl
+{
+    template<class Class, class RType, class...Ps>
+    RType type_fn(RType(Class::*)(Ps...));
+    template<class T>
+    using ret_t = decltype(type_fn(&T::clear));
+
+    template<class T, class = void>
+    struct member_rtype {};
+    template<class T>
+    struct member_rtype<T, std::void_t<ret_t<T>>>
+    {
+        using type = ret_t<T>;
+    };
+
+    template<class T, class = void>
+    struct member_exists : std::false_type {};
+    template<class T>
+    struct member_exists<T, std::void_t<ret_t<T>>> : std::true_type {};
+}
+
+//meta fncs namespaced by class
+namespace simox::meta::member::method::clear
+{
+    template<class T> using exists                   = impl::member_exists<T>;
+    template<class T> static constexpr bool exists_v = exists<T>::value;
+    template<class T> using return_type              = impl::member_rtype<T>;
+    template<class T> using return_type_t            = typename return_type<T>::type;
+}
+
+//exists_v
+namespace simox::meta::member::method::exists_v
+{
+    template<class T>
+    static constexpr bool clear = ::simox::meta::member::method::clear::exists_v<T>;
+}
+//concept
+namespace simox::meta::member::method::ccept
+{
+    template<class T>
+    concept clear = ::simox::meta::member::method::clear::exists_v<T>;
+}
+//return_type_t
+namespace simox::meta::member::method::return_type_t
+{
+    template<class T>
+    using clear = simox::meta::member::method::clear::return_type_t<T>;
+}