add ArxTypeTraits

master
Hideaki Tai 4 years ago
parent a7fb95ce81
commit 91dd8bc6fa

@ -252,6 +252,7 @@ Please use only sender OR receiver.
## Embedded Libraries
- [ArxContainer v0.3.9](https://github.com/hideakitai/ArxContainer)
- [ArxTypeTraits v0.2.0](https://github.com/hideakitai/ArxTypeTraits)
- [TeensyDirtySTLErrorSolution v0.1.0](https://github.com/hideakitai/TeensyDirtySTLErrorSolution)

@ -0,0 +1,42 @@
#pragma once
#ifndef ARX_TYPE_TRAITS_H
#define ARX_TYPE_TRAITS_H
#if __cplusplus < 201103L
#error "C++11 must be enabled in the compiler for this library to work, please check your compiler flags"
#endif
#include "ArxTypeTraits/has_include.h"
#include "ArxTypeTraits/has_libstdcplusplus.h"
// Make sure std namespace exists
namespace std { }
// Import everything from the std namespace into arx::std, so that
// anything we import rather than define is also available through
// arx::arx_std.
// This includes everything yet to be defined, so we can do this early
// (and must do so, to allow e.g. the C++14 additions in the arx::std
// namespace to reference the C++11 stuff from the system headers.
namespace arx {
namespace arx_std {
using namespace ::std;
}
}
// Import everything from arx::std back into the normal std namespace.
// This ensures that you can just use `std::foo` everywhere and you get
// the standard library version if it is available, falling back to arx
// versions for things not supplied by the standard library. Only when
// you really need the arx version (e.g. for constexpr numeric_limits
// when also using ArduinoSTL), you need to qualify with arx::arx_std::
namespace std {
using namespace ::arx::arx_std;
}
#include "ArxTypeTraits/replace_minmax_macros.h"
#include "ArxTypeTraits/type_traits.h"
#endif // ARX_TYPE_TRAITS_H

@ -0,0 +1,165 @@
#pragma once
#ifndef ARX_TYPE_TRAITS_FUNCTIONAL_H
#define ARX_TYPE_TRAITS_FUNCTIONAL_H
#if ARX_HAVE_LIBSTDCPLUSPLUS >= 201103L // Have libstdc++11
#include <functional>
#else // Do not have libstdc++11
// If we have a <new> header, include it and assume it has placement new
// (for AVR this has always been true, MEGAAVR does not have placement
// new now, but will probably get it before <new> is added).
// This also handles the case where ArduinoSTL is used, which defines an
// inline placement new which would conflict with the below definition.
#if ARX_SYSTEM_HAS_INCLUDE(<new>)
#include <new>
#else
// When there is no <new> header, there might be a <new.h> header, but
// not all Arduino platform (versions) define a placement new operator
// in there.
// However, it is hard to detect whether it is or is not defined, but
// the versions that do define it, do not define it inline in the
// header, so we can just define it inline here without conflicts.
// Note that there is no need to include anything to declare the
// non-placement new operators, since those are implicit.
inline void* operator new (const size_t size, void* ptr) noexcept { (void)size; return ptr; }
#endif
namespace arx { namespace arx_std {
// reference:
// stack overflow https://stackoverflow.com/questions/32074410/stdfunction-bind-like-type-erasure-without-standard-c-library
template<class Signature>
class function;
template<class R, class... Args>
class function<R(Args...)>
{
struct vtable_t
{
void (*mover)(void* src, void* dest);
void (*destroyer)(void*);
R (*invoke)(void const* t, Args&&... args);
template <class T>
static vtable_t const* get()
{
static const vtable_t table =
{
// mover
[] (void* src, void* dest)
{
new(dest) T(move(*static_cast<T*>(src)));
},
// destroyer
[] (void* t)
{
static_cast<T*>(t)->~T();
},
// invoke
[] (void const* t, Args&&... args) -> R
{
return (*static_cast<T const*>(t))(std::forward<Args>(args)...);
}
};
return &table;
}
};
vtable_t const* table {nullptr};
void* data {nullptr};
public:
template <
class Func,
class dF = typename std::decay<Func>::type,
typename enable_if <!std::is_same<dF, function>{}>::type* = nullptr,
typename enable_if <std::is_convertible<typename result_of<dF&(Args...)>::type, R>{}>::type* = nullptr
>
function(const Func& f)
: table(vtable_t::template get<dF>())
{
data = reinterpret_cast<void*>(new Func(f));
}
function(const function& o)
: table(o.table)
{
data = o.data;
}
function(function&& o)
: table(o.table)
{
if (table) table->mover(o.data, data);
}
function()
{
}
~function()
{
if (table) table->destroyer(data);
}
function& operator= (const function& o)
{
this->~function();
new(this) function(move(o));
return *this;
}
function& operator= (function&& o)
{
this->~function();
new(this) function(move(o));
return *this;
}
function& operator= (std::nullptr_t p)
{
(void)p;
this->~function();
return *this;
}
explicit operator bool() const
{
return table;
}
R operator()(Args...args) const
{
return table->invoke(data, forward<Args>(args)...);
}
};
template<class R, class... Args>
inline bool operator== (const function<R(Args...)>& f, std::nullptr_t)
{
return !static_cast<bool>(f);
}
template<class R, class... Args>
inline bool operator== (std::nullptr_t, const function<R(Args...)>& f)
{
return !static_cast<bool>(f);
}
template<class R, class... Args>
inline bool operator!= (const function<R(Args...)>& f, std::nullptr_t)
{
return static_cast<bool>(f);
}
template<class R, class... Args>
inline bool operator!= (std::nullptr_t, const function<R(Args...)>& f)
{
return static_cast<bool>(f);
}
} } // namespace arx::std
#endif // Do not have libstdc++11
#endif // ARX_TYPE_TRAITS_FUNCTIONAL_H

@ -0,0 +1,29 @@
#pragma once
#ifndef ARX_TYPE_TRAITS_HAS_INCLUDE_H
#define ARX_TYPE_TRAITS_HAS_INCLUDE_H
// Check whether __has_include is available, but also check the GCC
// version (__has_include was introduced in gcc 5) to catch
// environments (such as ESP8266) where gcc is old, but some system
// header provides a fake __has_include. We also need to check
// against __clang__ here, since clang pretends to be GCC
// 4.something and would otherwise be detected incorrectly here...
#if !defined(__has_include) || defined(__GNUC__) && __GNUC__ < 5 && !defined(__clang__)
#if defined(ARDUINO_ARCH_ESP8266)
// ESP8266 does not have a working __has_include, but we
// know it does have a working libstdc++ with all the
// headers we care about, so provide a fake has_include
#define ARX_SYSTEM_HAS_INCLUDE(x) 1
#elif defined(ARDUINO_SAM_DUE)
// Arduino DUE's GCC version is 4.8.3 (GCC < 5.0).
// And it has not libstdc++
#define ARX_SYSTEM_HAS_INCLUDE(x) 0
#else
#error "Compiler does not support __has_include, please report a bug against the ArxTypeTraits library about this."
#endif
#else
#define ARX_SYSTEM_HAS_INCLUDE(x) __has_include(x)
#endif
#endif // ARX_TYPE_TRAITS_HAS_INCLUDE_H

@ -0,0 +1,25 @@
#pragma once
#ifndef ARX_TYPE_TRAITS_HAS_LIBSTDCPLUSPLUS_H
#define ARX_TYPE_TRAITS_HAS_LIBSTDCPLUSPLUS_H
#if !defined(ARX_HAVE_LIBSTDCPLUSPLUS)
#if ARX_SYSTEM_HAS_INCLUDE(<cstdlib>)
#include <cstdlib>
#if defined(__GLIBCXX__) || defined(_LIBCPP_VERSION)
// For gcc's libstdc++ and clang's libc++, assume that
// __cplusplus tells us what the standard includes support
#define ARX_HAVE_LIBSTDCPLUSPLUS __cplusplus
#elif defined(__UCLIBCXX_MAJOR__)
// For uclibc++, assume C++98 support only.
#define ARX_HAVE_LIBSTDCPLUSPLUS 199711L
#else
#error "Unknown C++ library found, please report a bug against the ArxTypeTraits library about this."
#endif
#else
// Assume no standard library is available at all (e.g. on AVR)
#define ARX_HAVE_LIBSTDCPLUSPLUS 0
#endif
#endif
#endif // ARX_TYPE_TRAITS_HAS_LIBSTDCPLUSPLUS_H

@ -0,0 +1,30 @@
#pragma once
#ifndef ARX_TYPE_TRAITS_INITIALIZER_H
#define ARX_TYPE_TRAITS_INITIALIZER_H
// Initializer_list *must* be defined in std, so take extra care to only
// define it when <initializer_list> is really not available (e.g.
// ArduinoSTL is C++98 but *does* define <initializer_list>) and not
// already defined (e.g. by ArxContainer).
#if ARX_SYSTEM_HAS_INCLUDE(<initializer_list>)
#include <initializer_list>
#else
namespace std {
template<class T>
class initializer_list
{
private:
const T* array;
size_t len;
initializer_list(const T* a, size_t l) : array(a), len(l) {}
public:
initializer_list() : array(nullptr), len(0) {}
size_t size() const { return len; }
const T *begin() const { return array; }
const T *end() const { return array + len; }
};
} // namespace std
#endif
#endif // ARX_TYPE_TRAITS_INITIALIZER_LIST_H

@ -0,0 +1,33 @@
#pragma once
#ifndef ARX_TYPE_TRAITS_REPLACE_MINMAX_MACROS_H
#define ARX_TYPE_TRAITS_REPLACE_MINMAX_MACROS_H
// Make sure Arduino.h is actually included, since otherwise it might be
// included later and break *uses* of the min/max methods, rather than
// the declarations of it.
#include <Arduino.h>
// These macros are defined by Arduino.h on some platforms, and conflict
// with min/max methods defined or included by ArxTypeTraits, so replace
// them with macros here.
#ifdef max
#undef max
template <typename T1, typename T2>
constexpr auto max(T1 x, T2 y)
-> decltype(x + y)
{
return (x > y) ? x : y;
}
#endif
#ifdef min
#undef min
template <typename T1, typename T2>
constexpr auto min(T1 x, T2 y)
-> decltype(x + y)
{
return (x < y) ? x : y;
}
#endif
#endif // ARX_TYPE_TRAITS_REPLACE_MINMAX_MACROS_H

@ -0,0 +1,82 @@
#pragma once
#ifndef ARX_TYPE_TRAITS_TUPLE_H
#define ARX_TYPE_TRAITS_TUPLE_H
#if ARX_HAVE_LIBSTDCPLUSPLUS >= 201103L // Have libstdc++11
#include <tuple>
#else // Do not have libstdc++11
namespace arx { namespace arx_std {
// https://theolizer.com/cpp-school2/cpp-school2-15/
// https://wandbox.org/permlink/C0BWIzjqg4iO3kKZ
template<typename... Ts>
struct tuple
{
tuple() {}
};
template<typename tFirst, typename... tRest>
class tuple<tFirst, tRest...> : public tuple<tRest...>
{
template<size_t N, typename... tTypes> friend struct get_helper;
tFirst mMember;
public:
tuple(tFirst const& iFirst, tRest const&... iRest)
: tuple<tRest...>(iRest...)
, mMember(iFirst)
{ }
constexpr tuple() {}
};
template<size_t N, typename... tTypes>
struct get_helper { };
template<typename tFirst, typename... tRest>
struct get_helper<0, tFirst, tRest...>
{
typedef tFirst type;
static type& get(tuple<tFirst, tRest...>& iTuple)
{
return iTuple.mMember;
}
};
template<size_t N, typename tFirst, typename... tRest>
struct get_helper<N, tFirst, tRest...>
{
typedef typename get_helper<N - 1, tRest...>::type type;
static type& get(tuple<tFirst, tRest...>& iTuple)
{
return get_helper<N - 1, tRest...>::get(iTuple);
}
};
template<size_t N, typename... tTypes>
typename get_helper<N, tTypes...>::type& get(tuple<tTypes...>& iTuple)
{
return get_helper<N, tTypes...>::get(iTuple);
}
template <class T> class tuple_size;
template <class T> class tuple_size<const T>;
template <class T> class tuple_size<volatile T>;
template <class T> class tuple_size<const volatile T>;
template <class... Types>
class tuple_size <tuple<Types...>>
: public integral_constant <size_t, sizeof...(Types)> {};
template <class... Types>
auto make_tuple(Types&&... args)
-> std::tuple<typename std::remove_reference<Types>::type...>
{
return std::tuple<typename std::remove_reference<Types>::type...>(std::forward<typename std::remove_reference<Types>::type>(args)...);
}
} } // namespace arx::std
#endif // Do not have libstdc++11
#endif // ARX_TYPE_TRAITS_TUPLE_H

@ -0,0 +1,617 @@
#pragma once
#ifndef ARX_TYPE_TRAITS_TYPE_TRAITS_H
#define ARX_TYPE_TRAITS_TYPE_TRAITS_H
#if ARX_HAVE_LIBSTDCPLUSPLUS >= 199711L // Have libstdc++98
#include <utility>
#else // Do not have libstdc++98
namespace arx { namespace arx_std {
template <class T>
void swap(T& a, T& b)
{
T t = move(a);
a = move(b);
b = move(t);
}
} } // namespace arx::arx_std
#endif // Do not have libstdc++98
#if ARX_HAVE_LIBSTDCPLUSPLUS >= 201103L // Have libstdc++11
#include <limits>
#include <type_traits>
#else // Do not have libstdc++11
#include <float.h>
#include <limits.h>
#include <stdint.h>
namespace arx { namespace arx_std {
using nullptr_t = decltype(nullptr);
// numeric_limits
template <typename T>
struct numeric_limits
{
static constexpr T max() { return T(); }
static constexpr T min() { return T(); }
};
template <> constexpr bool numeric_limits<bool>::max() { return true; }
template <> constexpr char numeric_limits<char>::max() { return CHAR_MAX; }
template <> constexpr signed char numeric_limits<signed char>::max() { return SCHAR_MAX; }
template <> constexpr unsigned char numeric_limits<unsigned char>::max() { return UCHAR_MAX; }
template <> constexpr wchar_t numeric_limits<wchar_t>::max() { return WCHAR_MAX; }
// template <> constexpr char8_t numeric_limits<char8_t>::max() { return UCHAR_MAX; }
template <> constexpr char16_t numeric_limits<char16_t>::max() { return UINT_LEAST16_MAX; }
template <> constexpr char32_t numeric_limits<char32_t>::max() { return UINT_LEAST32_MAX; }
template <> constexpr short numeric_limits<short>::max() { return SHRT_MAX; }
template <> constexpr unsigned short numeric_limits<unsigned short>::max() { return USHRT_MAX; }
template <> constexpr int numeric_limits<int>::max() { return INT_MAX; }
template <> constexpr unsigned int numeric_limits<unsigned int>::max() { return UINT_MAX; }
template <> constexpr long numeric_limits<long>::max() { return LONG_MAX; }
template <> constexpr unsigned long numeric_limits<unsigned long>::max() { return ULONG_MAX; }
// template <> constexpr long long numeric_limits<long long>::max() { return LLONG_MAX; }
// template <> constexpr unsigned long long numeric_limits<unsigned long long>::max() { return ULLONG_MAX; }
template <> constexpr float numeric_limits<float>::max() { return FLT_MAX; }
template <> constexpr double numeric_limits<double>::max() { return DBL_MAX; }
template <> constexpr long double numeric_limits<long double>::max() { return LDBL_MAX; }
template <> constexpr bool numeric_limits<bool>::min() { return false; }
template <> constexpr char numeric_limits<char>::min() { return CHAR_MIN; }
template <> constexpr signed char numeric_limits<signed char>::min() { return SCHAR_MIN; }
template <> constexpr unsigned char numeric_limits<unsigned char>::min() { return 0; }
template <> constexpr wchar_t numeric_limits<wchar_t>::min() { return WCHAR_MIN; }
// template <> constexpr char8_t numeric_limits<char8_t>::min() { return 0; }
template <> constexpr char16_t numeric_limits<char16_t>::min() { return 0; }
template <> constexpr char32_t numeric_limits<char32_t>::min() { return 0; }
template <> constexpr short numeric_limits<short>::min() { return SHRT_MIN; }
template <> constexpr unsigned short numeric_limits<unsigned short>::min() { return 0; }
template <> constexpr int numeric_limits<int>::min() { return INT_MIN; }
template <> constexpr unsigned int numeric_limits<unsigned int>::min() { return 0; }
template <> constexpr long numeric_limits<long>::min() { return LONG_MIN; }
template <> constexpr unsigned long numeric_limits<unsigned long>::min() { return 0; }
// template <> constexpr long long numeric_limits<long long>::min() { return LLONG_MIN; }
// template <> constexpr unsigned long long numeric_limits<unsigned long long>::min() { return 0; }
template <> constexpr float numeric_limits<float>::min() { return FLT_MIN; }
template <> constexpr double numeric_limits<double>::min() { return DBL_MIN; }
template <> constexpr long double numeric_limits<long double>::min() { return LDBL_MIN; }
// integral_constant
template<class T, T v>
struct integral_constant
{
static constexpr T value = v;
using value_type = T;
using type = integral_constant;
constexpr operator value_type() const noexcept { return value; }
constexpr value_type operator()() const noexcept { return value; }
};
using true_type = integral_constant<bool, true>;
using false_type = integral_constant<bool, false>;
template <class T>
T declval(); // no implementation
template <bool, typename T = void>
struct enable_if;
template <typename T>
struct enable_if <true, T> { using type = T; };
template<bool, class T, class F>
struct conditional { using type = T; };
template<class T, class F>
struct conditional<false, T, F> { using type = F; };
template <class T> struct remove_cv { using type = T; };
template <class T> struct remove_cv<const T> { using type = T; };
template <class T> struct remove_cv<volatile T> { using type = T; };
template <class T> struct remove_cv<const volatile T> { using type = T; };
template <class T> struct remove_const { using type = T; };
template <class T> struct remove_const<const T> { using type = T; };
template <class T> struct remove_volatile { using type = T; };
template <class T> struct remove_volatile<volatile T> { using type = T; };
template <class T> struct remove_pointer { using type = T; };
template <class T> struct remove_pointer<T*> { using type = T; };
template <class T> struct remove_pointer<T* const> { using type = T; };
template <class T> struct remove_pointer<T* volatile> { using type = T; };
template <class T> struct remove_pointer<T* const volatile> { using type = T; };
template <class T> struct remove_reference { using type = T; };
template <class T> struct remove_reference<T&> { using type = T; };
template <class T> struct remove_reference<T&&> { using type = T; };
template<class T> struct remove_extent { typedef T type; };
template<class T> struct remove_extent<T[]> { typedef T type; };
template<class T, size_t N> struct remove_extent<T[N]> { typedef T type; };
template<class T>
T&& move(T& t){ return static_cast<T&&>(t); }
template <class T>
constexpr T&& forward(typename remove_reference<T>::type& t) noexcept
{
return static_cast<T&&>(t);
}
template <class T>
constexpr T&& forward(typename remove_reference<T>::type&& t) noexcept
{
return static_cast<T&&>(t);
}
namespace detail
{
template <class T>
struct type_identity { using type = T; };
template <class T>
auto try_add_pointer(int) -> type_identity<typename remove_reference<T>::type*>;
template <class T>
auto try_add_pointer(...) -> type_identity<T>;
}
template <class T>
struct add_pointer : decltype(detail::try_add_pointer<T>(0)) {};
template <typename T, typename U>
struct is_same : false_type {};
template <typename T>
struct is_same <T, T> : true_type {};
template <typename T>
struct is_integral : false_type {};
template <> struct is_integral <bool> : true_type {};
template <> struct is_integral <char> : true_type {};
template <> struct is_integral <signed char> : true_type {};
template <> struct is_integral <unsigned char> : true_type {};
template <> struct is_integral <char16_t> : true_type {};
template <> struct is_integral <char32_t> : true_type {};
template <> struct is_integral <wchar_t> : true_type {};
template <> struct is_integral <short> : true_type {};
template <> struct is_integral <unsigned short> : true_type {};
template <> struct is_integral <int> : true_type {};
template <> struct is_integral <unsigned> : true_type {};
template <> struct is_integral <long> : true_type {};
template <> struct is_integral <unsigned long> : true_type {};
template <> struct is_integral <long long> : true_type {};
template <> struct is_integral <unsigned long long> : true_type {};
template <typename T>
struct is_floating_point : false_type {};
template <> struct is_floating_point<float> : true_type {};
template <> struct is_floating_point<double> : true_type {};
template <> struct is_floating_point<long double> : true_type {};
template <typename T>
struct is_arithmetic
: conditional<
is_integral<T>::value || is_floating_point<T>::value,
true_type,
false_type
>::type
{};
namespace detail
{
template <typename T, bool = is_arithmetic<T>::value>
struct is_signed : integral_constant<bool, T(-1) < T(0)> {};
template <typename T>
struct is_signed<T, false> : false_type {};
}
template <typename T>
struct is_signed : detail::is_signed<T>::type {};
namespace detail
{
template<typename T, bool = is_arithmetic<T>::value>
struct is_unsigned : integral_constant<bool, T(0) < T(-1)> {};
template<typename T>
struct is_unsigned<T, false> : false_type {};
}
template<typename T>
struct is_unsigned : detail::is_unsigned<T>::type {};
template <class T> struct is_pointer_helper : false_type {};
template <class T> struct is_pointer_helper<T*> : true_type {};
template <class T> struct is_pointer : is_pointer_helper<typename remove_cv<T>::type> {};
template<class T>
struct is_array : false_type {};
template<class T>
struct is_array<T[]> : true_type {};
template<class T, size_t N>
struct is_array<T[N]> : true_type {};
namespace details
{
template <class... Ts>
struct Tester { using type = void; };
template <class... Ts>
using void_t = typename Tester<Ts...>::type;
template<template<class...>class Z, class, class...Ts>
struct can_apply : false_type{};
template<template<class...>class Z, class...Ts>
struct can_apply<Z, void_t<Z<Ts...>>, Ts...> : true_type{};
template<class From, class To>
using try_convert = decltype(To{declval<From>()});
}
template<template<class...>class Z, class...Ts>
using can_apply = details::can_apply<Z, void, Ts...>;
template<class From, class To>
struct is_convertible
: conditional <
can_apply <details::try_convert, From, To>::value
, true_type
, typename conditional <
is_arithmetic<From>::value && is_arithmetic<To>::value,
true_type,
false_type
>::type
>::type
{};
template<>
struct is_convertible<void, void> : true_type{};
// primary template
template<class>
struct is_function : false_type { };
// specialization for regular functions
template<class Ret, class... Args>
struct is_function<Ret(Args...)> : true_type {};
// specialization for variadic functions such as printf
template<class Ret, class... Args>
struct is_function<Ret(Args......)> : true_type {};
// specialization for function types that have cv-qualifiers
template<class Ret, class... Args>
struct is_function<Ret(Args...) const> : true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) volatile> : true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) const volatile> : true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) const> : true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) volatile> : true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) const volatile> : true_type {};
// specialization for function types that have ref-qualifiers
template<class Ret, class... Args>
struct is_function<Ret(Args...) &> : true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) const &> : true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) volatile &> : true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) const volatile &> : true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) &> : true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) const &> : true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) volatile &> : true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) const volatile &> : true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) &&> : true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) const &&> : true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) volatile &&> : true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) const volatile &&> : true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) &&> : true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) const &&> : true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) volatile &&> : true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) const volatile &&> : true_type {};
template<typename T>
struct is_empty : public integral_constant<bool, __is_empty(T)> { };
template <class T>
class decay
{
typedef typename remove_reference<T>::type U;
public:
typedef typename conditional<
is_array<U>::value,
typename remove_extent<U>::type*,
typename conditional<
is_function<U>::value,
typename add_pointer<U>::type,
typename remove_cv<U>::type
>::type
>::type type;
};
namespace details
{
template<class T> struct tag { using type=T; };
template<class Tag> using type_t = typename Tag::type;
template<class G, class...Args>
using invoke_t = decltype( declval<G>()(declval<Args>()...) );
template<class Sig, class = void>
struct result_of {};
template<class G, class...Args>
struct result_of<G(Args...), void_t<invoke_t<G, Args...>>>
: tag <invoke_t<G, Args...>>
{};
}
template<class Sig>
using result_of = details::result_of<Sig>;
} } // namespace arx::arx_std
#endif // Do not have libstdc++11
#include "initializer_list.h"
#include "tuple.h"
#include "functional.h"
#if ARX_HAVE_LIBSTDCPLUSPLUS >= 201402L // Have libstdc++14
// Nothing to include here, relevant header files were already included
// for C++11 above.
#else // Do not have libstdc++14
namespace arx { namespace arx_std {
template <bool B, typename T = void>
using enable_if_t = typename enable_if<B, T>::type;
template <typename T>
using decay_t = typename decay<T>::type;
template<class T>
using remove_cv_t = typename remove_cv<T>::type;
template<class T>
using remove_const_t = typename remove_const<T>::type;
template<class T>
using remove_volatile_t = typename remove_volatile<T>::type;
template<class T>
using remove_reference_t = typename remove_reference<T>::type;
template<class T>
using remove_pointer_t = typename remove_pointer<T>::type;
template<typename T, T ...Ts>
struct integer_sequence
{
using type = integer_sequence;
using value_type = T;
static constexpr size_t size() noexcept { return sizeof...(Ts); }
};
template <size_t ...Is>
using index_sequence = integer_sequence<size_t, Is...>;
// https://stackoverflow.com/questions/17424477/implementation-c14-make-integer-sequence
template<typename S1, typename S2>
struct concat_impl;
template<typename S1, typename S2>
using concat = typename concat_impl<S1, S2>::type;
template<size_t... I1, size_t... I2>
struct concat_impl <index_sequence<I1...>, index_sequence<I2...>>
: index_sequence<I1..., (sizeof...(I1) + I2)...> {};
template<size_t N>
struct make_index_sequence_impl;
template<size_t N>
using make_index_sequence = typename make_index_sequence_impl<N>::type;
template<size_t N>
struct make_index_sequence_impl
: concat<make_index_sequence <N/2>, make_index_sequence <N - N/2>> {};
template<>
struct make_index_sequence_impl <0> : index_sequence<>{};
template<>
struct make_index_sequence_impl <1> : index_sequence<0>{};
template<typename... Ts>
using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
} } // namespace arx::arx_std
#endif // Do not have libstdc++14
#if ARX_HAVE_LIBSTDCPLUSPLUS >= 201703L // Have libstdc++17
// Nothing to include here, relevant header files were already included
// for C++11 above.
#else // Do not have libstdc++17
namespace arx { namespace arx_std {
template <class... Ts>
struct Tester { using type = void; };
template <class... Ts>
using void_t = typename Tester<Ts...>::type;
template <typename ...Args>
struct disjunction : false_type {};
template <typename Arg>
struct disjunction <Arg> : Arg::type {};
template <typename Arg, typename ...Args>
struct disjunction <Arg, Args...> : conditional<Arg::value, Arg, disjunction<Args...>>::type {};
template <typename ...Args>
struct conjunction : true_type {};
template <typename Arg>
struct conjunction <Arg> : Arg::type {};
template <typename Arg, typename ...Args>
struct conjunction <Arg, Args...> : conditional<Arg::value, conjunction<Args...>, Arg>::type {};
template <typename T>
struct negation : integral_constant<bool, !T::value> {};
// https://qiita.com/_EnumHack/items/92e6e135174f1f781dbb
// without decltype(auto)
template <class F, class Tuple, size_t... I>
constexpr auto apply_impl(F&& f, Tuple&& t, index_sequence<I...>)
-> decltype(f(get<I>(forward<Tuple>(t))...))
{
return f(get<I>(forward<Tuple>(t))...);
}
template <class F, class Tuple>
constexpr auto apply(F&& f, Tuple&& t)
-> decltype(apply_impl(
forward<F>(f),
forward<Tuple>(t),
make_index_sequence<tuple_size<decay_t<Tuple>>::value>{}
))
{
return apply_impl(
forward<F>(f),
forward<Tuple>(t),
make_index_sequence<tuple_size<decay_t<Tuple>>::value>()
);
}
} } // namespace arx::arx_std
#endif // Do not have libstdc++17
#if ARX_HAVE_LIBSTDCPLUSPLUS > 201703L // Have libstdc++2a
// Nothing to include here, relevant header files were already included
// for C++11 above.
#else // Do not have libstdc++2a
namespace arx { namespace arx_std {
template<class T>
struct remove_cvref
{
typedef remove_cv_t<remove_reference_t<T>> type;
};
template< class T >
using remove_cvref_t = typename remove_cvref<T>::type;
} } // namespace arx::arx_std
#endif // Do not have libstdc++2a
namespace arx { // others
template <class AlwaysVoid, template<class...> class Check, class... T>
struct is_detected_impl : std::false_type {};
template <template <class...> class Check, class... T>
struct is_detected_impl <std::void_t<Check<T...>>, Check, T...> : std::true_type {};
template <template <class...> class Check, class... T>
using is_detected = is_detected_impl<void, Check, T...>;
template <typename T>
struct is_callable {
template <typename U, decltype(&U::operator()) = &U::operator()>
struct checker {};
template <typename U> static std::true_type test(checker<U> *);
template <typename> static std::false_type test(...);
static constexpr bool value = decltype(test<T>(nullptr))::value;
};
template <typename R, typename ... Arguments>
struct is_callable<R(*)(Arguments ...)> {
static constexpr bool value = true;
};
template <typename R, typename ... Arguments>
struct is_callable<R(*&)(Arguments ...)> {
static constexpr bool value = true;
};
template <typename R, typename ... Arguments>
struct is_callable<R(&)(Arguments ...)> {
static constexpr bool value = true;
};
template <typename R, typename ... Arguments>
struct is_callable<R(Arguments ...)> {
static constexpr bool value = true;
};
template <typename R, typename ... Arguments>
struct is_callable<std::function<R(Arguments ...)>> {
static constexpr bool value = true;
};
namespace detail {
template <typename ret, typename ... arguments>
struct function_traits {
static constexpr size_t arity = sizeof...(arguments);
using result_type = ret;
using arguments_types_tuple = std::tuple<arguments ...>;
// template <size_t index>
// using argument_type = type_at<index, arguments ...>;
using function_type = std::function<ret(arguments ...)>;
template <typename function_t>
static constexpr function_type cast(function_t f) {
return static_cast<function_type>(f);
}
};
};
template <typename T>
struct function_traits : public function_traits<decltype(&T::operator())> {};
template <typename class_type, typename ret, typename ... arguments>
struct function_traits<ret(class_type::*)(arguments ...) const>
: detail::function_traits<ret, arguments ...> {};
template <typename class_type, typename ret, typename ... arguments>
struct function_traits<ret(class_type::*)(arguments ...)>
: detail::function_traits<ret, arguments ...> {};
template <typename ret, typename ... arguments>
struct function_traits<ret(*)(arguments ...)>
: detail::function_traits<ret, arguments ...> {};
template <typename ret, typename ... arguments>
struct function_traits<ret(*&)(arguments ...)>
: detail::function_traits<ret, arguments ...> {};
template <typename ret, typename ... arguments>
struct function_traits<ret(arguments ...)>
: detail::function_traits<ret, arguments ...> {};
template <typename ret, typename ... arguments>
struct function_traits<std::function<ret(arguments ...)>>
: detail::function_traits<ret, arguments ...> {};
} // namespace arx
#endif // ARX_TYPE_TRAITS_TYPE_TRAITS_H

@ -0,0 +1,21 @@
MIT License
Copyright (c) 2020 Hideaki Tai
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

@ -0,0 +1,114 @@
# ArxTypeTraits
C++ type_traits for Arduino which cannot use it as default
## Features
- automatically use standard library first if the boards can
- if standard library is not enough (e.g. only C++11 is available), add missing parts listed below
- works almost all Arduino platforms (Let me know if you have errors)
- compatible with [ArduinoSTL](https://github.com/mike-matera/ArduinoSTL) or other [uClibc++](https://www.uclibc.org/) libraries (include them before `ArxTypeTraits`)
- thx @matthijskooijman
## Supported Class Templates
### C++11 (defined only for platforms above which cannot use `type_traits`)
- `std::integral_constant`
- `std::true_type`
- `std::false_type`
- `std::declval`
- `std::enable_if`
- `std::conditional`
- `std::remove_cv`
- `std::remove_const`
- `std::remove_volatile`
- `std::remove_pointer`
- `std::remove_reference`
- `std::remove_extent`
- `std::add_pointer`
- `std::forward`
- `std::is_same`
- `std::is_integral`
- `std::is_floating_point`
- `std::is_arithmetic`
- `std::is_signed`
- `std::is_unsigned`
- `std::is_pointer`
- `std::is_array`
- `std::is_convertible`
- `std::is_function`
- `std::is_empty`
- `std::decay`
- `std::result_of`
#### for utility
- `std::numeric_limits` (only `max()` and `min()` now)
- `std::swap`
- `std::initializer_list`
- `std::tuple`
- `std::get`
- `std::tuple_size`
- `std::function`
### C++14 (defined only for boards before C++14)
- `std::enable_if_t`
- `std::decay_t`
- `std::remove_cv_t`
- `std::remove_const_t`
- `std::remove_volatile_t`
- `std::remove_reference_t`
- `std::remove_pointer_t`
- `std::integer_sequence`
- `std::index_sequence`
- `std::make_index_sequence`
- `std::index_sequence_for`
### C++17 (defined only for boards before C++17)
- `std::void_t`
- `std::disjunction`
- `std::conjunction`
- `std::negation`
- `std::apply`
### C++2a
- `std::remove_cvref`
- `std::remove_cvref_t`
### Others (defined for all boards)
- `arx::is_detected`
- `arx::is_callable`
- `arx::function_traits`
## Used Inside of
- [Packetizer](https://github.com/hideakitai/Packetizer)
- [MsgPack](https://github.com/hideakitai/MsgPack)
- [MsgPacketizer](https://github.com/hideakitai/MsgPacketizer)
- [ArduinoOSC](https://github.com/hideakitai/ArduinoOSC)
- [PollingTimer](https://github.com/hideakitai/PollingTimer)
- [Tween](https://github.com/hideakitai/Tween)
- [ArxStringUtils](https://github.com/hideakitai/ArxStringUtils)
## Contributors
- [Matthijs Kooijman](https://github.com/matthijskooijman)
## License
MIT

@ -0,0 +1,18 @@
{
"name": "ArxTypeTraits",
"keywords": "type traits, functional, tuple, stl",
"description": "C++ type_traits for Arduino which cannot use it as default",
"repository": {
"type": "git",
"url": "https://github.com/hideakitai/ArxTypeTraits.git"
},
"authors": {
"name": "Hideaki Tai",
"url": "https://github.com/hideakitai",
"maintainer": true
},
"version": "0.2.0",
"license": "MIT",
"frameworks": "arduino",
"platforms": "*"
}

@ -0,0 +1,9 @@
name=ArxTypeTraits
version=0.2.0
author=hideakitai
maintainer=hideakitai
sentence=C++ type_traits for Arduino which cannot use it as default
paragraph=C++ type_traits for Arduino which cannot use it as default
category=Data Storage
url=https://github.com/hideakitai/ArxTypeTraits
architectures=*
Loading…
Cancel
Save