ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
mbed-os/platform/mbed_cxxsupport.h

1229 lines
35 KiB
C++
Raw Blame History

/* mbed Microcontroller Library
* Copyright (c) 2019 ARM Limited
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MBED_CXXSUPPORT_H
#define MBED_CXXSUPPORT_H
#include "mbed_toolchain.h"
/* Mbed OS code is expected to work as C++14 or later, but
* we currently also want to not totally break ARM Compiler 5, which has a
* subset of C++11 language and no C++11 library.
*
* This adaptation file fills out missing namespace std functionality for
* ARM Compiler 5, and backports some post-C++14 features into namespace mbed.
*/
/* Macros that can be used to mark functions and objects that are
* constexpr in C++14 or later, but not in earlier versions.
*/
#if __cplusplus >= 201402
#define MBED_CONSTEXPR_FN_14 constexpr
#define MBED_CONSTEXPR_OBJ_14 constexpr
#else
#define MBED_CONSTEXPR_FN_14 inline
#define MBED_CONSTEXPR_OBJ_14 const
#endif
// The template stuff in here is too confusing for astyle
// *INDENT-OFF*
/* Start with some core C++11 type trait building blocks for ARMC5 */
#ifdef __CC_ARM
/* ARMC5 lacks alignof and alignas keyword - do the best we can */
/* alignof */
#define alignof(T) __alignof__(T)
/* alignas(N) */
/* Types not supported - workaround is to use alignas(alignof(T)), which is legal anyway */
#ifndef __alignas_is_defined
#define __alignas_is_defined
#define alignas(N) __attribute__((aligned(N)))
#endif
namespace std {
/* integral_constant */
template <typename T, T V>
struct integral_constant {
using value_type = T;
using type = integral_constant;
static constexpr T value = V;
constexpr operator T() const noexcept
{
return V;
}
constexpr T operator()() const noexcept
{
return V;
}
};
template<typename T, T V>
constexpr T integral_constant<T, V>::value;
/* true_type, false_type */
using true_type = integral_constant<bool, true>;
using false_type = integral_constant<bool, false>;
} // namespace std
#else
#include <cstddef>
#include <type_traits>
#include <utility>
#endif
/* Add some foundational stuff from C++17 or later or TS into namespace mbed */
namespace mbed {
/* C++20 type identity */
template<typename T>
struct type_identity {
using type = T;
};
template <typename T>
using type_identity_t = typename type_identity<T>::type;
/* C++17 void_t (foundation for detection idiom) */
/* void_t<Args...> is void if args are valid, else a substitution failure */
#if __cplusplus >= 201703 || __cpp_lib_void_t >= 201411
using std::void_t;
#elif defined __CC_ARM
namespace impl {
template <typename...>
struct void_helper : type_identity<void> { };
}
template <typename... Ts>
using void_t = typename impl::void_helper<Ts...>::type;
#else
template <typename...>
using void_t = void;
#endif
/* C++17 bool_constant */
#if __cplusplus >= 201703 || __cpp_lib_bool_constant >= 201505
using std::bool_constant;
#else
template <bool B>
using bool_constant = std::integral_constant<bool, B>;
#endif
} // namespace mbed
#ifdef __CC_ARM
/* Fill in core missing C++11/C++14 functionality for ARM C 5 into namespace std */
/* First, the things needed to support the detector idiom. */
namespace std {
/* is_same */
template <typename, typename>
struct is_same : false_type { };
template <typename T>
struct is_same<T, T> : true_type { };
/* conditional */
template <bool B, typename T, typename F>
struct conditional : mbed::type_identity<F> { };
template <typename T, typename F>
struct conditional<true, T, F> : mbed::type_identity<T> { };
template <bool B, typename T, typename F>
using conditional_t = typename conditional<B, T, F>::type;
/* enable_if */
template <bool B, typename T = void>
struct enable_if { };
template <typename T>
struct enable_if<true, T> : mbed::type_identity<T> { };
template <bool B, typename T = void>
using enable_if_t = typename enable_if<B, T>::type;
/* Forward declarations */
template <typename From, typename To>
struct is_convertible;
template <typename T>
struct is_object;
template <typename T>
struct is_reference;
} // namespace std
#endif // __CC_ARM
/* Reinvent or pull in good stuff not in C++14 into namespace mbed */
namespace mbed {
/* C++17 logical operations on traits */
#if __cplusplus >= 201703 || __cpp_lib_logical_traits >= 201510
using std::conjunction;
using std::disjunction;
using std::negation;
#else
template<class...>
struct conjunction : std::true_type { };
template<class B1>
struct conjunction<B1> : B1 { };
template<class B1, class... BN>
struct conjunction<B1, BN...> : std::conditional_t<bool(B1::value), conjunction<BN...>, B1> { };
template<class...>
struct disjunction : std::false_type { };
template<class B1>
struct disjunction<B1> : B1 { };
template<class B1, class... BN>
struct disjunction<B1, BN...> : std::conditional_t<bool(B1::value), B1, disjunction<BN...>> { };
template<class B>
struct negation : bool_constant<!bool(B::value)> { };
#endif
/* C++ detection idiom from Library fundamentals v2 TS */
/* Place into mbed::experimental to match their std::experimental */
namespace experimental {
namespace impl {
template <class Default, class Void, template<class...> class Op, class... Args>
struct detector {
using value_t = std::false_type;
using type = Default;
};
template <class Default, template<class...> class Op, class... Args>
struct detector<Default, void_t<Op<Args...>>, Op, Args...> {
using value_t = std::true_type;
using type = Op<Args...>;
};
} // namespace impl
struct nonesuch {
~nonesuch() = delete;
nonesuch(nonesuch const &) = delete;
void operator=(nonesuch const &) = delete;
};
#if 0
/* Deactivated because impl::detector appears to not work on ARM C 5; it seems to produce
* hard errors in the template template parameter expansion. You can use void_t directly instead.
*
* Reactivate if working ARM C 5 implementation discovered, or ARM C 5 support
* dropped.
*/
template<template<class...> class Op, class... Args>
using is_detected = typename impl::detector<nonesuch, void, Op, Args...>::value_t;
template<template<class...> class Op, class... Args>
using detected_t = typename impl::detector<nonesuch, void, Op, Args...>::type;
template<class Default, template<class...> class Op, class... Args>
using detected_or = typename impl::detector<Default, void, Op, Args...>;
template<class Default, template<class...> class Op, class... Args>
using detected_or_t = typename detected_or<Default, Op, Args...>::type;
template<class Expected, template<class...> class Op, class... Args>
using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
template<class To, template<class...> class Op, class... Args>
using is_detected_convertible = std::is_convertible<detected_t<Op, Args...>, To>;
#endif // if 0 - deactivated detector idiom
} // namespace experimental
} // namespace mbed
#ifdef __CC_ARM
/* More missing C++11/C++14 functionality for ARM C 5 */
#include <iterator>
namespace std {
/* nullptr_t */
using nullptr_t = decltype(nullptr);
/* maxalign_t */
union maxalign_t { long double ld; long long ll; };
/* remove_const/volatile/cv */
template <typename T>
struct remove_const : mbed::type_identity<T> { };
template <typename T>
struct remove_const<const T> : mbed::type_identity<T> { };
template <typename T>
using remove_const_t = typename remove_const<T>::type;
template <typename T>
struct remove_volatile : mbed::type_identity<T> { };
template <typename T>
struct remove_volatile<volatile T> : mbed::type_identity<T> { };
template <typename T>
using remove_volatile_t = typename remove_volatile<T>::type;
template <typename T>
struct remove_cv : remove_volatile<remove_const_t<T>> { };
template <typename T>
using remove_cv_t = typename remove_cv<T>::type;
/* add_const/volatile/cv */
template <typename T>
struct add_const : mbed::type_identity<const T> { };
template <typename T>
using add_const_t = typename add_const<T>::type;
template <typename T>
struct add_volatile : mbed::type_identity<volatile T> { };
template <typename T>
using add_volatile_t = typename add_volatile<T>::type;
template <typename T>
struct add_cv : mbed::type_identity<const volatile T> { };
template <typename T>
using add_cv_t = typename add_cv<T>::type;
/* remove_reference */
template <typename T>
struct remove_reference : mbed::type_identity<T> { };
template <typename T>
struct remove_reference<T &> : mbed::type_identity<T> { };
template <typename T>
struct remove_reference<T &&> : mbed::type_identity<T> { };
template <typename T>
using remove_reference_t = typename remove_reference<T>::type;
/* add_lvalue_reference / add_value_reference */
namespace impl {
template <typename T> // Base test - objects and references
struct is_referenceable : mbed::disjunction<is_object<T>, is_reference<T>> { };
template <typename R, typename... Args> // Specialisation - unqualified functions (non-variadic)
struct is_referenceable<R(Args...)> : true_type { };
template <typename R, typename... Args> // Specialisation - unqualified functions (variadic)
struct is_referenceable<R(Args... ...)> : true_type { };
template <typename T, bool = is_referenceable<T>::value>
struct add_lvalue_reference : mbed::type_identity<T> { };
template <typename T>
struct add_lvalue_reference<T, true> : mbed::type_identity<T &> { };
template <typename T, bool = is_referenceable<T>::value>
struct add_rvalue_reference : mbed::type_identity<T> { };
template <typename T>
struct add_rvalue_reference<T, true> : mbed::type_identity<T &&> { };
} // namespace impl
template <typename T>
struct add_lvalue_reference : impl::add_lvalue_reference<T> { };
template <typename T>
using add_lvalue_reference_t = typename add_lvalue_reference<T>::type;
template <typename T>
struct add_rvalue_reference : impl::add_rvalue_reference<T> { };
template <typename T>
using add_rvalue_reference_t = typename add_rvalue_reference<T>::type;
/* declval */
template <class T>
add_rvalue_reference_t<T> declval() noexcept;
/* is_void */
template <typename T>
struct is_void : is_same<void, remove_cv_t<T>> { };
/* is_null_pointer */
template <typename T>
struct is_null_pointer : is_same<nullptr_t, remove_cv_t<T>> { };
/* is_integral */
template <typename T>
struct is_integral :
mbed::disjunction<
is_same<bool, remove_cv_t<T>>,
is_same<char, remove_cv_t<T>>,
is_same<signed char, remove_cv_t<T>>,
is_same<unsigned char, remove_cv_t<T>>,
is_same<char16_t, remove_cv_t<T>>,
is_same<char32_t, remove_cv_t<T>>,
is_same<wchar_t, remove_cv_t<T>>,
is_same<short, remove_cv_t<T>>,
is_same<unsigned short, remove_cv_t<T>>,
is_same<int, remove_cv_t<T>>,
is_same<unsigned int, remove_cv_t<T>>,
is_same<long, remove_cv_t<T>>,
is_same<unsigned long, remove_cv_t<T>>,
is_same<long long, remove_cv_t<T>>,
is_same<unsigned long long, remove_cv_t<T>>> { };
/* is_floating_point */
template <typename T>
struct is_floating_point :
mbed::disjunction<
is_same<float, remove_cv_t<T>>,
is_same<double, remove_cv_t<T>>,
is_same<long double, remove_cv_t<T>>> { };
/* is_array */
template <typename T>
struct is_array : false_type { };
template <typename T>
struct is_array<T[]> : true_type { };
template <typename T, size_t N>
struct is_array<T[N]> : true_type { };
/* is_pointer */
namespace impl {
template <typename T>
struct is_unqualified_pointer : false_type { };
template <typename T>
struct is_unqualified_pointer<T *> : true_type { };
} // namespace impl
template <typename T>
struct is_pointer : impl::is_unqualified_pointer<remove_cv_t<T>> { };
/* is_lvalue_reference */
template <typename T>
struct is_lvalue_reference : false_type { };
template <typename T>
struct is_lvalue_reference<T &> : true_type { };
/* is_rvalue_reference */
template <typename T>
struct is_rvalue_reference : false_type { };
template <typename T>
struct is_rvalue_reference<T &&> : true_type { };
/* is_enum */
template <typename T>
struct is_enum : mbed::bool_constant<__is_enum(T)> { };
/* is_union */
template <typename T>
struct is_union : mbed::bool_constant<__is_union(T)> { };
/* is_class */
template <typename T>
struct is_class : mbed::bool_constant<__is_class(T)> { };
/* is_function */
template <typename T>
struct is_function : false_type { };
template <typename R, typename... Args>
struct is_function<R(Args...)> : true_type { }; // 0 or more named arguments
template <typename R, typename... Args>
struct is_function<R(Args... ...)> : true_type { }; // 0 or more named arguments and variadic
template <typename R, typename... Args>
struct is_function<R(Args...) &> : true_type { };
template <typename R, typename... Args>
struct is_function<R(Args... ...) &> : true_type { };
template <typename R, typename... Args>
struct is_function<R(Args...) &&> : true_type { };
template <typename R, typename... Args>
struct is_function<R(Args... ...) &&> : true_type { };
template <typename R, typename... Args>
struct is_function<R(Args...) const> : true_type { };
template <typename R, typename... Args>
struct is_function<R(Args... ...) const> : true_type { };
template <typename R, typename... Args>
struct is_function<R(Args...) const &> : true_type { };
template <typename R, typename... Args>
struct is_function<R(Args... ...) const &> : true_type { };
template <typename R, typename... Args>
struct is_function<R(Args...) const &&> : true_type { };
template <typename R, typename... Args>
struct is_function<R(Args... ...) const &&> : true_type { };
template <typename R, typename... Args>
struct is_function<R(Args...) volatile> : true_type { };
template <typename R, typename... Args>
struct is_function<R(Args... ...) volatile> : true_type { };
template <typename R, typename... Args>
struct is_function<R(Args...) volatile &> : true_type { };
template <typename R, typename... Args>
struct is_function<R(Args... ...) volatile &> : true_type { };
template <typename R, typename... Args>
struct is_function<R(Args...) volatile &&> : true_type { };
template <typename R, typename... Args>
struct is_function<R(Args... ...) volatile &&> : true_type { };
template <typename R, typename... Args>
struct is_function<R(Args...) const volatile> : true_type { };
template <typename R, typename... Args>
struct is_function<R(Args... ...) const volatile> : true_type { };
template <typename R, typename... Args>
struct is_function<R(Args...) const volatile &> : true_type { };
template <typename R, typename... Args>
struct is_function<R(Args... ...) const volatile &> : true_type { };
template <typename R, typename... Args>
struct is_function<R(Args...) const volatile &&> : true_type { };
template <typename R, typename... Args>
struct is_function<R(Args... ...) const volatile &&> : true_type { };
/* is_member_function_pointer */
namespace impl {
/* Two helper filters to complement is_function */
template <typename>
using always_true = true_type;
template <typename T>
using is_not_function = mbed::negation<is_function<T>>;
template <typename T, template<typename> class Filter = always_true>
struct is_unqualified_member_pointer : false_type { };
template <typename T, template<typename> class Filter, typename U>
struct is_unqualified_member_pointer<T U::*, Filter> : Filter<T> { };
} // namespace impl
template <typename T>
struct is_member_function_pointer : impl::is_unqualified_member_pointer<remove_cv_t<T>, is_function> { };
/* is_member_object_pointer */
template <typename T>
struct is_member_object_pointer : impl::is_unqualified_member_pointer<remove_cv_t<T>, impl::is_not_function> { };
/* is_reference = (is_lvalue_reference || is_rvalue_reference) */
template <typename T>
struct is_reference : false_type { };
template <typename T>
struct is_reference<T &> : true_type { };
template <typename T>
struct is_reference<T &&> : true_type { };
/* is_arithmetic */
template <typename T>
struct is_arithmetic : mbed::disjunction<is_integral<T>, is_floating_point<T>> { };
/* is_fundamental */
template <typename T>
struct is_fundamental : mbed::disjunction<is_arithmetic<T>, is_void<T>, is_null_pointer<T>> { };
/* is_compound */
template <typename T>
struct is_compound : mbed::negation<is_fundamental<T>> { };
/* is_member_pointer */
template <typename T>
struct is_member_pointer : impl::is_unqualified_member_pointer<remove_cv_t<T>> { };
/* is_scalar */
template <typename T>
struct is_scalar : mbed::disjunction<is_arithmetic<T>, is_enum<T>, is_pointer<T>, is_member_pointer<T>, is_null_pointer<T>> { };
/* is_object */
template <typename T>
struct is_object : mbed::disjunction<is_scalar<T>, is_array<T>, is_union<T>, is_class<T>> { };
/* is_const */
template <typename T>
struct is_const : false_type { };
template <typename T>
struct is_const<const T> : true_type { };
/* is_volatile */
template <typename T>
struct is_volatile : false_type { };
template <typename T>
struct is_volatile<volatile T> : true_type { };
/* is_trivial */
template <typename T>
struct is_trivial : mbed::bool_constant<__is_trivial(T)> { };
/* is_trivially_copyable */
template <typename T>
struct is_trivially_copyable : mbed::bool_constant<__is_trivially_copyable(T)> { };
/* is_standard_layout */
template <typename T>
struct is_standard_layout : mbed::bool_constant<__is_standard_layout(T)> { };
/* is_pod */
template <typename T>
struct is_pod : mbed::bool_constant<__is_pod(T)> { };
/* is_literal_type */
template <typename T>
struct is_literal_type : mbed::bool_constant<__is_literal_type(T)> { };
/* is_empty */
template <typename T>
struct is_empty : mbed::bool_constant<__is_empty(T)> { };
/* is_polymorphic */
template <typename T>
struct is_polymorphic : mbed::bool_constant<__is_polymorphic(T)> { };
/* is_abstract */
template <typename T>
struct is_abstract : mbed::bool_constant<__is_abstract(T)> { };
/* is_final (C++14) not supported */
/* is_signed */
namespace impl {
template <typename T, bool = is_arithmetic<T>::value >
struct is_signed : false_type { };
template <typename T>
struct is_signed<T, true> : mbed::bool_constant<T(-1) < T(0)> { };
} // namespace impl
template <typename T>
struct is_signed : impl::is_signed<T> { };
/* is_unsigned */
namespace impl {
template <typename T, bool = is_arithmetic<T>::value >
struct is_unsigned : false_type { };
template <typename T>
struct is_unsigned<T, true> : mbed::bool_constant<T(0) < T(-1)> { };
}
template <typename T>
struct is_unsigned : impl::is_unsigned<T> { };
/* is_constructible */
template <typename T, typename... Args>
struct is_constructible : mbed::bool_constant<__is_constructible(T, Args...)> { };
/* is_default_constructible */
template <typename T>
struct is_default_constructible : is_constructible<T> { };
/* is_copy_constructible */
template <typename T>
struct is_copy_constructible : is_constructible<T, add_lvalue_reference_t<add_const_t<T>>> { };
/* is_move_constructible */
template <typename T>
struct is_move_constructible : is_constructible<T, add_rvalue_reference_t<T>> { };
/* is_assignable */
namespace impl {
template <typename To, typename From, typename = void>
struct is_assignable : std::false_type { };
template <typename To, typename From>
struct is_assignable<To, From, mbed::void_t<decltype(std::declval<To>() = std::declval<From>())>> : std::true_type { };
} // namespace impl
template <typename To, typename From>
struct is_assignable : impl::is_assignable<To, From> { };
/* is_copy_assignable */
template <typename T>
struct is_copy_assignable : is_assignable<add_lvalue_reference_t<T>,
add_lvalue_reference_t<add_const_t<T>>> { };
/* is_move_assignable */
template <typename T>
struct is_move_assignable : is_assignable<add_lvalue_reference_t<T>,
add_rvalue_reference_t<T>> { };
/* is_destructible */
template <typename T>
struct is_destructible : mbed::bool_constant<__is_destructible(T)> { };
/* is_trivially_constructible */
template <typename T, typename... Args>
struct is_trivially_constructible : mbed::bool_constant<__is_trivially_constructible(T, Args...)> { };
/* is_trivially_default_constructible */
template <typename T>
struct is_trivially_default_constructible : is_trivially_constructible<T> { };
/* is_trivially_copy_constructible */
template <typename T>
struct is_trivially_copy_constructible : is_trivially_constructible<T, add_lvalue_reference_t<add_const_t<T>>> { };
/* is_trivially_move_constructible */
template <typename T>
struct is_trivially_move_constructible : is_trivially_constructible<T, add_rvalue_reference_t<T>> { };
/* is_trivially_assignable */
template <typename To, typename From>
struct is_trivially_assignable : mbed::bool_constant<__is_trivially_assignable(To, From)> { };
/* is_trivially_copy_assignable */
template <typename T>
struct is_trivially_copy_assignable : is_trivially_assignable<add_lvalue_reference_t<T>,
add_lvalue_reference_t<add_const_t<T>>> { };
/* is_trivially_move_assignable */
template <typename T>
struct is_trivially_move_assignable : is_trivially_assignable<add_lvalue_reference_t<T>,
add_rvalue_reference_t<T>> { };
/* is_trivially_destructible */
template <typename T>
struct is_trivially_destructible : mbed::bool_constant<__is_trivially_destructible(T)> { };
/* is_nothrow_constructible */
template <typename T, typename... Args>
struct is_nothrow_constructible : mbed::bool_constant<__is_nothrow_constructible(T, Args...)> { };
/* is_nothrow_default_constructible */
template <typename T>
struct is_nothrow_default_constructible : is_nothrow_constructible<T> { };
/* is_nothrow_copy_constructible */
template <typename T>
struct is_nothrow_copy_constructible : is_nothrow_constructible<T, add_lvalue_reference_t<add_const_t<T>>> { };
/* is_nothrow_move_constructible */
template <typename T>
struct is_nothrow_move_constructible : is_nothrow_constructible<T, add_rvalue_reference_t<T>> { };
/* is_nothrow_assignable */
template <typename To, typename From>
struct is_nothrow_assignable : mbed::bool_constant<__is_nothrow_assignable(To, From)> { };
/* is_copy_assignable */
template <typename T>
struct is_nothrow_copy_assignable : is_nothrow_assignable<add_lvalue_reference_t<T>,
add_lvalue_reference_t<add_const_t<T>>> { };
/* is_move_assignable */
template <typename T>
struct is_nothrow_move_assignable : is_nothrow_assignable<add_lvalue_reference_t<T>,
add_rvalue_reference_t<T>> { };
/* is_nothrow_destructible */
template <typename T>
struct is_nothrow_destructible : mbed::bool_constant<__is_nothrow_destructible(T)> { };
/* has_virtual_destructor */
template <typename T>
struct has_virtual_destructor : mbed::bool_constant<__has_virtual_destructor(T)> { };
/* alignment_of */
template <typename T>
struct alignment_of : integral_constant<size_t, alignof(T)> { };
/* rank */
template <typename T>
struct rank : integral_constant<size_t, 0> { };
template <typename T>
struct rank<T[]> : integral_constant<size_t, rank<T>::value + 1u> { };
template <typename T, size_t N>
struct rank<T[N]> : integral_constant<size_t, rank<T>::value + 1u> { };
/* extent */
template <typename T, unsigned I = 0>
struct extent : integral_constant<size_t, 0> { };
template <typename T>
struct extent<T[], 0> : integral_constant<size_t, 0> { };
template <typename T, unsigned I>
struct extent<T[], I> : extent<T, I - 1> { };
template <typename T, size_t N>
struct extent<T[N], 0> : integral_constant<size_t, N> { };
template <typename T, size_t N, unsigned I>
struct extent<T[N], I> : extent<T, I - 1> { };
/* is_convertible */
/* __is_convertible_to apparently returns true for any From if To is void */
template <typename From, typename To>
struct is_convertible : conditional_t<is_void<To>::value,
is_void<From>,
mbed::bool_constant<__is_convertible_to(From, To)>> { };
/* is_base_of */
template <typename Base, typename Derived>
struct is_base_of : mbed::bool_constant<__is_base_of(Base, Derived) && __is_class(Derived)> { };
/* remove_extent */
template <typename T>
struct remove_extent : mbed::type_identity<T> { };
template <typename T>
struct remove_extent<T[]> : mbed::type_identity<T> { };
template <typename T, size_t N>
struct remove_extent<T[N]> : mbed::type_identity<T> { };
template <typename T>
using remove_extent_t = typename remove_extent<T>::type;
/* remove_all_extents */
template <typename T>
struct remove_all_extents : mbed::type_identity<T> { };
template <typename T>
using remove_all_extents_t = typename remove_all_extents<T>::type;
template <typename T>
struct remove_all_extents<T[]> : mbed::type_identity<remove_all_extents_t<T>> { };
template <typename T, size_t N>
struct remove_all_extents<T[N]> : mbed::type_identity<remove_all_extents_t<T>> { };
/* remove_pointer */
template <typename T>
struct remove_pointer : mbed::type_identity<T> { };
template <typename T>
struct remove_pointer<T *> : mbed::type_identity<T> { };
template <typename T>
struct remove_pointer<T * const> : mbed::type_identity<T> { };
template <typename T>
struct remove_pointer<T * volatile> : mbed::type_identity<T> { };
template <typename T>
struct remove_pointer<T * const volatile> : mbed::type_identity<T> { };
template <typename T>
using remove_pointer_t = typename remove_pointer<T>::type;
/* add_pointer */
namespace impl {
template <typename T, bool = mbed::disjunction<is_referenceable<T>, is_void<T>>::value>
struct add_pointer : mbed::type_identity<T> { };
template <typename T>
struct add_pointer<T, true> : mbed::type_identity<remove_reference_t<T> *> { };
} // namespace impl
template <typename T>
struct add_pointer : impl::add_pointer<T> { };
template <typename T>
using add_pointer_t = typename add_pointer<T>::type;
/* aligned_storage */
namespace impl {
constexpr size_t possible_alignment_requirement(size_t n)
{
return n <= 1 ? 1 :
n <= 2 ? 2 :
n <= 4 ? 4 : 8;
}
}
template <size_t Len, size_t Align = impl::possible_alignment_requirement(Len)>
struct aligned_storage {
struct type {
__attribute__((aligned(Align))) unsigned char data[Len];
};
};
template <size_t Len, size_t Align = impl::possible_alignment_requirement(Len)>
using aligned_storage_t = typename aligned_storage<Len, Align>::type;
/* decay */
namespace impl {
template <typename T>
struct decay : mbed::type_identity<
conditional_t<is_array<T>::value,
remove_extent_t<T>,
conditional_t<is_function<T>::value,
add_pointer_t<T>,
remove_cv_t<T>
>
>
> { };
} // namespace impl
template <typename T>
struct decay : impl::decay<remove_reference_t<T>> { };
template <typename T>
using decay_t = typename decay<T>::type;
/* common_type (0 types) */
template <typename...>
struct common_type { };
template <typename... T>
using common_type_t = typename common_type<T...>::type;
namespace impl {
template <typename T1, typename T2>
using ternary_t = decltype(false ? declval<T1>() : declval<T2>());
template <typename T1, typename T2, typename=void>
struct ct2_default { };
template <typename T1, typename T2>
struct ct2_default<T1, T2, mbed::void_t<ternary_t<T1, T2>>> : mbed::type_identity<decay_t<ternary_t<T1, T2>>> { };
template <typename T1, typename T2, typename D1 = decay_t<T1>, typename D2 = decay_t<T2>>
struct ct2 : common_type<D1, D2> { };
template <typename D1, typename D2>
struct ct2<D1, D2, D1, D2> : ct2_default<D1, D2> { };
template <typename Void, typename T1, typename T2, typename... TN>
struct ct_multi { };
template <typename T1, typename T2, typename... TN>
struct ct_multi<mbed::void_t<common_type<T1, T2>>, T1, T2, TN...> : common_type<common_type_t<T1, T2>, TN...> { };
} // namespace impl
/* common_type (1 type) */
template <typename T>
struct common_type<T> : common_type<T, T> { };
/* common_type (2 types) - applications can add extra 2-type specializations */
template <typename T1, typename T2>
struct common_type<T1, T2> : impl::ct2<T1, T2> { };
/* common_type (3+ types) */
template <typename T1, typename T2, typename... TN>
struct common_type<T1, T2, TN...> : impl::ct_multi<void, T1, T2, TN...> { };
/* underlying_type */
template <typename T>
struct underlying_type : mbed::type_identity<__underlying_type(T)> { };
template <typename T>
using underlying_type_t = typename underlying_type<T>::type;
/* result_of not implemented */
/* addressof */
template <typename T>
T *addressof(T &arg) noexcept
{
return reinterpret_cast<T *>(const_cast<char *>(&reinterpret_cast<const volatile char &>(arg)));
}
/* move */
template <typename T>
constexpr remove_reference_t<T> &&move(T &&a) noexcept
{
return static_cast<remove_reference_t<T> &&>(a);
}
/* forward */
template <typename T>
constexpr T &&forward(remove_reference_t<T> &a) noexcept
{
return static_cast<T &&>(a);
}
template <typename T>
constexpr T &&forward(remove_reference_t<T> &&a) noexcept
{
return static_cast<T &&>(a);
}
/* std::array is pretty useful */
template <class T, size_t N>
struct array {
T _elem[N];
using value_type = T;
using size_type = size_t;
using difference_type = ptrdiff_t;
using reference = T &;
using const_reference = const T &;
using pointer = T *;
using const_pointer = const T *;
using iterator = T *;
using const_iterator = const T *;
using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
T &at(size_t pos)
{
MBED_ASSERT(pos < size());
return _elem[pos];
}
const T &at(size_t pos) const
{
MBED_ASSERT(pos < size());
return _elem[pos];
}
T &operator[](size_t pos)
{
return _elem[pos];
}
const T &operator[](size_t pos) const
{
return _elem[pos];
}
T &front()
{
return _elem[0];
}
const T &front() const
{
return _elem[0];
}
T &back()
{
return _elem[N - 1];
}
const T &back() const
{
return _elem[N - 1];
}
T *data() noexcept
{
return _elem;
}
const T *data() const noexcept
{
return _elem;
}
constexpr bool empty() const noexcept
{
return false;
}
constexpr size_t size() const noexcept
{
return N;
}
constexpr size_t max_size() const noexcept
{
return N;
}
void fill(const T &value)
{
std::fill(begin(), end(), value);
}
iterator begin() noexcept
{
return _elem;
}
const_iterator begin() const noexcept
{
return _elem;
}
const_iterator cbegin() const noexcept
{
return _elem;
}
iterator end() noexcept
{
return _elem + N;
}
const_iterator end() const noexcept
{
return _elem + N;
}
const_iterator cend() const noexcept
{
return _elem + N;
}
reverse_iterator rbegin() noexcept
{
return reverse_iterator(end());
}
const_reverse_iterator rbegin() const noexcept
{
return const_reverse_iterator(end());
}
const_reverse_iterator crbegin() const noexcept
{
return const_reverse_iterator(end());
}
reverse_iterator rend() noexcept
{
return reverse_iterator(begin());
}
const_reverse_iterator rend() const noexcept
{
return const_reverse_iterator(begin());
}
const_reverse_iterator crend() const noexcept
{
return const_reverse_iterator(begin());
}
};
/* ARM Compiler 5 supports initializer lists, but is missing std::initializer_list */
/* Implementation deduced experimentally */
template <class T>
struct initializer_list {
using value_type = T;
using reference = const T &;
using const_reference = const T &;
using size_type = size_t;
using iterator = const T *;
using const_iterator = const T *;
constexpr initializer_list() noexcept : _ptr(nullptr), _count(0)
{
}
constexpr initializer_list(const T *p, size_t n) noexcept : _ptr(p), _count(n)
{
}
constexpr size_t size() const noexcept
{
return _count;
}
const T *begin() const noexcept
{
return _ptr;
}
const T *end() const noexcept
{
return _ptr + _count;
}
private:
const T *_ptr;
size_t _count;
};
/* begin */
template <class C>
auto begin(C &c) -> decltype(c.begin())
{
return c.begin();
}
template <class C>
auto begin(const C &c) -> decltype(c.begin())
{
return c.begin();
}
template <class T, size_t N>
T *begin(T (&array)[N]) noexcept
{
return &array[0];
}
template <class C>
auto cbegin(const C &c) noexcept(noexcept(begin(c))) -> decltype(begin(c))
{
return begin(c);
}
/* begin(initializer_list<E>) */
template <class E>
const E begin(initializer_list<E> il) noexcept
{
return il.begin();
}
/* end */
template <class C>
auto end(C &c) -> decltype(c.end())
{
return c.end();
}
template <class C>
auto end(const C &c) -> decltype(c.end())
{
return c.end();
}
template <class T, size_t N>
T *end(T (&array)[N]) noexcept
{
return &array[N];
}
template <class C>
auto cend(const C &c) noexcept(noexcept(end(c))) -> decltype(end(c))
{
return end(c);
}
/* end(initializer_list<E>) */
template <class E>
const E end(initializer_list<E> il) noexcept
{
return il.end();
}
/* align */
inline void *align(size_t alignment, size_t size, void *&ptr, size_t &space) noexcept
{
/* Behavior is undefined if alignment is not a power of 2 */
uintptr_t addr = reinterpret_cast<uintptr_t>(ptr);
uintptr_t new_addr = (addr + (alignment - 1)) & ~(alignment - 1);
uintptr_t pad = new_addr - addr;
if (pad + size <= space) {
space -= pad;
ptr = reinterpret_cast<void *>(new_addr);
return ptr;
} else {
return nullptr;
}
}
} // namespace std
#endif // __CC_ARM
/* More post-C++14 stuff */
namespace mbed {
/* C++17 as_const */
#if __cplusplus >= 201703 || __cpp_lib_as_const >= 201510
using std::as_const;
#else
template <typename T>
constexpr std::add_const_t<T> &as_const(T &t) noexcept
{
return t;
}
template <typename T>
void as_const(T &&) = delete;
#endif
/* C++20 remove_cvref */
template <typename T>
struct remove_cvref : type_identity<std::remove_cv_t<std::remove_reference_t<T>>> { };
template <typename T>
using remove_cvref_t = typename remove_cvref<T>::type;
} // namespace mbed
#endif // MBED_CXXSUPPORT_H
Reference in New Issue View Git Blame Copy Permalink