diff --git a/Telegram/ThirdParty/GSL/.gitrepo b/Telegram/ThirdParty/GSL/.gitrepo index fe307c63c..a71262877 100644 --- a/Telegram/ThirdParty/GSL/.gitrepo +++ b/Telegram/ThirdParty/GSL/.gitrepo @@ -6,6 +6,6 @@ [subrepo] remote = https://github.com/Microsoft/GSL.git branch = master - commit = 1c95f9436eae69c9b9315911ef6aa210df7d1e31 - parent = 0dde6bbc3b558644359e5ee49725e508babcea8b + commit = c9e423d7cf2afb88672e31f55e4b30c53be7aae3 + parent = dde6ba57a8584fda72b205bd8aff8ce452bdc8de cmdver = 0.3.1 diff --git a/Telegram/ThirdParty/GSL/CMakeLists.txt b/Telegram/ThirdParty/GSL/CMakeLists.txt index 53058e348..dcb6d8929 100644 --- a/Telegram/ThirdParty/GSL/CMakeLists.txt +++ b/Telegram/ThirdParty/GSL/CMakeLists.txt @@ -1,4 +1,4 @@ -cmake_minimum_required(VERSION 3.1.3) +cmake_minimum_required(VERSION 3.7) project(GSL CXX) @@ -16,7 +16,7 @@ endif () # when minimum version required is 3.8.0 remove if below # both branches do exactly the same thing -if (CMAKE_MAJOR_VERSION VERSION_LESS 3.7.9) +if (CMAKE_VERSION VERSION_LESS 3.7.9) if (NOT MSVC) include(CheckCXXCompilerFlag) CHECK_CXX_COMPILER_FLAG("-std=c++14" COMPILER_SUPPORTS_CXX14) @@ -49,10 +49,18 @@ target_include_directories(GSL INTERFACE > ) +if (MSVC_IDE) + option(VS_ADD_NATIVE_VISUALIZERS "Configure project to use Visual Studio native visualizers" TRUE) +else() + set(VS_ADD_NATIVE_VISUALIZERS FALSE CACHE INTERNAL "Native visualizers are Visual Studio extension" FORCE) +endif() + # add natvis file to the library so it will automatically be loaded into Visual Studio -target_sources(GSL INTERFACE - ${CMAKE_CURRENT_SOURCE_DIR}/GSL.natvis -) +if(VS_ADD_NATIVE_VISUALIZERS) + target_sources(GSL INTERFACE + ${CMAKE_CURRENT_SOURCE_DIR}/GSL.natvis + ) +endif() install( DIRECTORY include/gsl diff --git a/Telegram/ThirdParty/GSL/GSL.natvis b/Telegram/ThirdParty/GSL/GSL.natvis index e40a8c9fe..a467a17de 100644 --- a/Telegram/ThirdParty/GSL/GSL.natvis +++ b/Telegram/ThirdParty/GSL/GSL.natvis @@ -11,7 +11,7 @@ - + {{ invoke = {invoke_}, action = {f_} }} invoke_ diff --git a/Telegram/ThirdParty/GSL/README.md b/Telegram/ThirdParty/GSL/README.md index 1c8449068..419430dd6 100644 --- a/Telegram/ThirdParty/GSL/README.md +++ b/Telegram/ThirdParty/GSL/README.md @@ -34,6 +34,7 @@ The test suite that exercises GSL has been built and passes successfully on the * OS X Yosemite using GCC-5.2.0 * OS X Sierra 10.12.4 using Apple LLVM version 8.1.0 (Clang-802.0.42) * OS X El Capitan (10.11) using Xcode with AppleClang 8.0.0.8000042 +* OS X High Sierra 10.13.2 (17C88) using Apple LLVM version 9.0.0 (clang-900.0.39.2) * FreeBSD 10.x with Clang/LLVM 3.6 > If you successfully port GSL to another platform, we would love to hear from you. Please submit an issue to let us know. Also please consider @@ -44,7 +45,7 @@ contributing any changes that were necessary back to this project to benefit the ## Building the tests To build the tests, you will require the following: -* [CMake](http://cmake.org), version 3.1.3 or later to be installed and in your PATH. +* [CMake](http://cmake.org), version 3.7 or later to be installed and in your PATH. These steps assume the source code of this repository has been cloned into a directory named `c:\GSL`. diff --git a/Telegram/ThirdParty/GSL/include/gsl/gsl b/Telegram/ThirdParty/GSL/include/gsl/gsl index ec9632cfb..55862ebdd 100644 --- a/Telegram/ThirdParty/GSL/include/gsl/gsl +++ b/Telegram/ThirdParty/GSL/include/gsl/gsl @@ -17,11 +17,13 @@ #ifndef GSL_GSL_H #define GSL_GSL_H -#include // Ensures/Expects -#include // finally()/narrow()/narrow_cast()... -#include // multi_span, strided_span... -#include // span -#include // zstring, string_span, zstring_builder... -#include // owner, not_null +#include // copy +#include // Ensures/Expects +#include // byte +#include // finally()/narrow()/narrow_cast()... +#include // multi_span, strided_span... +#include // owner, not_null +#include // span +#include // zstring, string_span, zstring_builder... #endif // GSL_GSL_H diff --git a/Telegram/ThirdParty/GSL/include/gsl/gsl_algorithm b/Telegram/ThirdParty/GSL/include/gsl/gsl_algorithm index 9e6678a6b..710792fbd 100644 --- a/Telegram/ThirdParty/GSL/include/gsl/gsl_algorithm +++ b/Telegram/ThirdParty/GSL/include/gsl/gsl_algorithm @@ -17,9 +17,12 @@ #ifndef GSL_ALGORITHM_H #define GSL_ALGORITHM_H -#include +#include // for Expects +#include // for dynamic_extent, span -#include +#include // for copy_n +#include // for ptrdiff_t +#include // for is_assignable #ifdef _MSC_VER #pragma warning(push) diff --git a/Telegram/ThirdParty/GSL/include/gsl/gsl_assert b/Telegram/ThirdParty/GSL/include/gsl/gsl_assert index 2157673d2..eeb3473a5 100644 --- a/Telegram/ThirdParty/GSL/include/gsl/gsl_assert +++ b/Telegram/ThirdParty/GSL/include/gsl/gsl_assert @@ -18,7 +18,7 @@ #define GSL_CONTRACTS_H #include -#include +#include // for logic_error // // There are three configuration options for this GSL implementation's behavior @@ -52,12 +52,10 @@ // #ifdef _MSC_VER #define GSL_ASSUME(cond) __assume(cond) -#elif defined(__clang__) -#define GSL_ASSUME(cond) __builtin_assume(cond) #elif defined(__GNUC__) #define GSL_ASSUME(cond) ((cond) ? static_cast(0) : __builtin_unreachable()) #else -#define GSL_ASSUME(cond) static_cast(!!(cond)) +#define GSL_ASSUME(cond) static_cast((cond) ? 0 : 0) #endif // diff --git a/Telegram/ThirdParty/GSL/include/gsl/gsl_byte b/Telegram/ThirdParty/GSL/include/gsl/gsl_byte index 6e34a5541..5da9a865a 100644 --- a/Telegram/ThirdParty/GSL/include/gsl/gsl_byte +++ b/Telegram/ThirdParty/GSL/include/gsl/gsl_byte @@ -74,63 +74,63 @@ enum class byte : unsigned char }; template ::value>> -inline constexpr byte& operator<<=(byte& b, IntegerType shift) noexcept +constexpr byte& operator<<=(byte& b, IntegerType shift) noexcept { return b = byte(static_cast(b) << shift); } template ::value>> -inline constexpr byte operator<<(byte b, IntegerType shift) noexcept +constexpr byte operator<<(byte b, IntegerType shift) noexcept { return byte(static_cast(b) << shift); } template ::value>> -inline constexpr byte& operator>>=(byte& b, IntegerType shift) noexcept +constexpr byte& operator>>=(byte& b, IntegerType shift) noexcept { return b = byte(static_cast(b) >> shift); } template ::value>> -inline constexpr byte operator>>(byte b, IntegerType shift) noexcept +constexpr byte operator>>(byte b, IntegerType shift) noexcept { return byte(static_cast(b) >> shift); } -inline constexpr byte& operator|=(byte& l, byte r) noexcept +constexpr byte& operator|=(byte& l, byte r) noexcept { return l = byte(static_cast(l) | static_cast(r)); } -inline constexpr byte operator|(byte l, byte r) noexcept +constexpr byte operator|(byte l, byte r) noexcept { return byte(static_cast(l) | static_cast(r)); } -inline constexpr byte& operator&=(byte& l, byte r) noexcept +constexpr byte& operator&=(byte& l, byte r) noexcept { return l = byte(static_cast(l) & static_cast(r)); } -inline constexpr byte operator&(byte l, byte r) noexcept +constexpr byte operator&(byte l, byte r) noexcept { return byte(static_cast(l) & static_cast(r)); } -inline constexpr byte& operator^=(byte& l, byte r) noexcept +constexpr byte& operator^=(byte& l, byte r) noexcept { return l = byte(static_cast(l) ^ static_cast(r)); } -inline constexpr byte operator^(byte l, byte r) noexcept +constexpr byte operator^(byte l, byte r) noexcept { return byte(static_cast(l) ^ static_cast(r)); } -inline constexpr byte operator~(byte b) noexcept { return byte(~static_cast(b)); } +constexpr byte operator~(byte b) noexcept { return byte(~static_cast(b)); } template ::value>> -inline constexpr IntegerType to_integer(byte b) noexcept +constexpr IntegerType to_integer(byte b) noexcept { return static_cast(b); } @@ -138,7 +138,7 @@ inline constexpr IntegerType to_integer(byte b) noexcept #endif // GSL_USE_STD_BYTE template -inline constexpr byte to_byte_impl(T t) noexcept +constexpr byte to_byte_impl(T t) noexcept { static_assert( E, "gsl::to_byte(t) must be provided an unsigned char, otherwise data loss may occur. " @@ -146,19 +146,19 @@ inline constexpr byte to_byte_impl(T t) noexcept return static_cast(t); } template <> -inline constexpr byte to_byte_impl(unsigned char t) noexcept +constexpr byte to_byte_impl(unsigned char t) noexcept { return byte(t); } template -inline constexpr byte to_byte(T t) noexcept +constexpr byte to_byte(T t) noexcept { return to_byte_impl::value, T>(t); } template -inline constexpr byte to_byte() noexcept +constexpr byte to_byte() noexcept { static_assert(I >= 0 && I <= 255, "gsl::byte only has 8 bits of storage, values must be in range 0-255"); diff --git a/Telegram/ThirdParty/GSL/include/gsl/gsl_util b/Telegram/ThirdParty/GSL/include/gsl/gsl_util index 86a3ad7f1..1aa8ba6e0 100644 --- a/Telegram/ThirdParty/GSL/include/gsl/gsl_util +++ b/Telegram/ThirdParty/GSL/include/gsl/gsl_util @@ -17,12 +17,14 @@ #ifndef GSL_UTIL_H #define GSL_UTIL_H -#include // Ensures/Expects +#include // for Expects #include -#include -#include -#include +#include // for ptrdiff_t, size_t +#include // for exception +#include // for initializer_list +#include // for is_signed, integral_constant +#include // for forward #if defined(_MSC_VER) @@ -41,47 +43,51 @@ namespace gsl // GSL.util: utilities // -// final_act allows you to ensure something gets run at the end of a scope +// index type for all container indexes/subscripts/sizes +using index = std::ptrdiff_t; + +// final_action allows you to ensure something gets run at the end of a scope template -class final_act +class final_action { public: - explicit final_act(F f) noexcept : f_(std::move(f)), invoke_(true) {} + explicit final_action(F f) noexcept : f_(std::move(f)) {} - final_act(final_act&& other) noexcept : f_(std::move(other.f_)), invoke_(other.invoke_) + final_action(final_action&& other) noexcept : f_(std::move(other.f_)), invoke_(other.invoke_) { other.invoke_ = false; } - final_act(const final_act&) = delete; - final_act& operator=(const final_act&) = delete; + final_action(const final_action&) = delete; + final_action& operator=(const final_action&) = delete; - ~final_act() noexcept + ~final_action() noexcept { if (invoke_) f_(); } private: F f_; - bool invoke_; + bool invoke_ {true}; }; -// finally() - convenience function to generate a final_act +// finally() - convenience function to generate a final_action template -inline final_act finally(const F& f) noexcept + +final_action finally(const F& f) noexcept { - return final_act(f); + return final_action(f); } template -inline final_act finally(F&& f) noexcept +final_action finally(F&& f) noexcept { - return final_act(std::forward(f)); + return final_action(std::forward(f)); } // narrow_cast(): a searchable way to do narrowing casts of values template -inline constexpr T narrow_cast(U&& u) noexcept +constexpr T narrow_cast(U&& u) noexcept { return static_cast(std::forward(u)); } @@ -101,7 +107,7 @@ namespace details // narrow() : a checked version of narrow_cast() that throws if the cast changed the value template -inline T narrow(U u) +T narrow(U u) { T t = narrow_cast(u); if (static_cast(t) != u) throw narrowing_error(); @@ -114,25 +120,25 @@ inline T narrow(U u) // at() - Bounds-checked way of accessing builtin arrays, std::array, std::vector // template -inline constexpr T& at(T (&arr)[N], const std::ptrdiff_t index) +constexpr T& at(T (&arr)[N], const index i) { - Expects(index >= 0 && index < narrow_cast(N)); - return arr[static_cast(index)]; + Expects(i >= 0 && i < narrow_cast(N)); + return arr[static_cast(i)]; } template -inline constexpr auto at(Cont& cont, const std::ptrdiff_t index) -> decltype(cont[cont.size()]) +constexpr auto at(Cont& cont, const index i) -> decltype(cont[cont.size()]) { - Expects(index >= 0 && index < narrow_cast(cont.size())); + Expects(i >= 0 && i < narrow_cast(cont.size())); using size_type = decltype(cont.size()); - return cont[static_cast(index)]; + return cont[static_cast(i)]; } template -inline constexpr T at(const std::initializer_list cont, const std::ptrdiff_t index) +constexpr T at(const std::initializer_list cont, const index i) { - Expects(index >= 0 && index < narrow_cast(cont.size())); - return *(cont.begin() + index); + Expects(i >= 0 && i < narrow_cast(cont.size())); + return *(cont.begin() + i); } } // namespace gsl diff --git a/Telegram/ThirdParty/GSL/include/gsl/multi_span b/Telegram/ThirdParty/GSL/include/gsl/multi_span index 4b2dc0f23..65e65a112 100644 --- a/Telegram/ThirdParty/GSL/include/gsl/multi_span +++ b/Telegram/ThirdParty/GSL/include/gsl/multi_span @@ -17,22 +17,24 @@ #ifndef GSL_MULTI_SPAN_H #define GSL_MULTI_SPAN_H -#include -#include -#include +#include // for Expects +#include // for byte +#include // for narrow_cast -#include -#include +#include // for transform, lexicographical_compare +#include // for array #include -#include -#include -#include -#include -#include +#include // for ptrdiff_t, size_t, nullptr_t +#include // for PTRDIFF_MAX +#include // for divides, multiplies, minus, negate, plus +#include // for initializer_list +#include // for iterator, random_access_iterator_tag +#include // for numeric_limits #include #include #include -#include +#include // for basic_string +#include // for enable_if_t, remove_cv_t, is_same, is_co... #include #ifdef _MSC_VER @@ -83,12 +85,12 @@ namespace details } template -class index final +class multi_span_index final { static_assert(Rank > 0, "Rank must be greater than 0!"); template - friend class index; + friend class multi_span_index; public: static const std::size_t rank = Rank; @@ -97,22 +99,22 @@ public: using reference = std::add_lvalue_reference_t; using const_reference = std::add_lvalue_reference_t>; - constexpr index() GSL_NOEXCEPT {} + constexpr multi_span_index() GSL_NOEXCEPT {} - constexpr index(const value_type (&values)[Rank]) GSL_NOEXCEPT + constexpr multi_span_index(const value_type (&values)[Rank]) GSL_NOEXCEPT { std::copy(values, values + Rank, elems); } template ::value>> - constexpr index(Ts... ds) GSL_NOEXCEPT : elems{narrow_cast(ds)...} + constexpr multi_span_index(Ts... ds) GSL_NOEXCEPT : elems{narrow_cast(ds)...} { } - constexpr index(const index& other) GSL_NOEXCEPT = default; + constexpr multi_span_index(const multi_span_index& other) GSL_NOEXCEPT = default; - constexpr index& operator=(const index& rhs) GSL_NOEXCEPT = default; + constexpr multi_span_index& operator=(const multi_span_index& rhs) GSL_NOEXCEPT = default; // Preconditions: component_idx < rank constexpr reference operator[](std::size_t component_idx) @@ -128,75 +130,75 @@ public: return elems[component_idx]; } - constexpr bool operator==(const index& rhs) const GSL_NOEXCEPT + constexpr bool operator==(const multi_span_index& rhs) const GSL_NOEXCEPT { return std::equal(elems, elems + rank, rhs.elems); } - constexpr bool operator!=(const index& rhs) const GSL_NOEXCEPT { return !(this == rhs); } + constexpr bool operator!=(const multi_span_index& rhs) const GSL_NOEXCEPT { return !(*this == rhs); } - constexpr index operator+() const GSL_NOEXCEPT { return *this; } + constexpr multi_span_index operator+() const GSL_NOEXCEPT { return *this; } - constexpr index operator-() const GSL_NOEXCEPT + constexpr multi_span_index operator-() const GSL_NOEXCEPT { - index ret = *this; + multi_span_index ret = *this; std::transform(ret, ret + rank, ret, std::negate{}); return ret; } - constexpr index operator+(const index& rhs) const GSL_NOEXCEPT + constexpr multi_span_index operator+(const multi_span_index& rhs) const GSL_NOEXCEPT { - index ret = *this; + multi_span_index ret = *this; ret += rhs; return ret; } - constexpr index operator-(const index& rhs) const GSL_NOEXCEPT + constexpr multi_span_index operator-(const multi_span_index& rhs) const GSL_NOEXCEPT { - index ret = *this; + multi_span_index ret = *this; ret -= rhs; return ret; } - constexpr index& operator+=(const index& rhs) GSL_NOEXCEPT + constexpr multi_span_index& operator+=(const multi_span_index& rhs) GSL_NOEXCEPT { std::transform(elems, elems + rank, rhs.elems, elems, std::plus{}); return *this; } - constexpr index& operator-=(const index& rhs) GSL_NOEXCEPT + constexpr multi_span_index& operator-=(const multi_span_index& rhs) GSL_NOEXCEPT { std::transform(elems, elems + rank, rhs.elems, elems, std::minus{}); return *this; } - constexpr index operator*(value_type v) const GSL_NOEXCEPT + constexpr multi_span_index operator*(value_type v) const GSL_NOEXCEPT { - index ret = *this; + multi_span_index ret = *this; ret *= v; return ret; } - constexpr index operator/(value_type v) const GSL_NOEXCEPT + constexpr multi_span_index operator/(value_type v) const GSL_NOEXCEPT { - index ret = *this; + multi_span_index ret = *this; ret /= v; return ret; } - friend constexpr index operator*(value_type v, const index& rhs) GSL_NOEXCEPT + friend constexpr multi_span_index operator*(value_type v, const multi_span_index& rhs) GSL_NOEXCEPT { return rhs * v; } - constexpr index& operator*=(value_type v) GSL_NOEXCEPT + constexpr multi_span_index& operator*=(value_type v) GSL_NOEXCEPT { std::transform(elems, elems + rank, elems, [v](value_type x) { return std::multiplies{}(x, v); }); return *this; } - constexpr index& operator/=(value_type v) GSL_NOEXCEPT + constexpr multi_span_index& operator/=(value_type v) GSL_NOEXCEPT { std::transform(elems, elems + rank, elems, [v](value_type x) { return std::divides{}(x, v); }); @@ -495,8 +497,8 @@ namespace details } template 1), - typename Ret = std::enable_if_t>> - inline constexpr Ret shift_left(const index& other) GSL_NOEXCEPT + typename Ret = std::enable_if_t>> + constexpr Ret shift_left(const multi_span_index& other) GSL_NOEXCEPT { Ret ret{}; for (std::size_t i = 0; i < Rank - 1; ++i) { @@ -533,7 +535,7 @@ public: static const std::ptrdiff_t static_size = MyRanges::TotalSize; using size_type = std::ptrdiff_t; - using index_type = index; + using index_type = multi_span_index; using const_index_type = std::add_const_t; using iterator = bounds_iterator; using const_iterator = bounds_iterator; @@ -629,9 +631,9 @@ public: return m_ranges.contains(idx) != -1; } - constexpr size_type operator[](std::size_t index) const GSL_NOEXCEPT + constexpr size_type operator[](std::size_t idx) const GSL_NOEXCEPT { - return m_ranges.elementNum(index); + return m_ranges.elementNum(idx); } template @@ -696,7 +698,7 @@ public: using const_reference = std::add_const_t; using size_type = value_type; using difference_type = value_type; - using index_type = index; + using index_type = multi_span_index; using const_index_type = std::add_const_t; using iterator = bounds_iterator; using const_iterator = bounds_iterator; @@ -804,17 +806,15 @@ struct is_bounds> : std::integral_constant }; template -class bounds_iterator : public std::iterator +class bounds_iterator { -private: - using Base = std::iterator; - public: static const std::size_t rank = IndexType::rank; - using typename Base::reference; - using typename Base::pointer; - using typename Base::difference_type; - using typename Base::value_type; + using iterator_category = std::random_access_iterator_tag; + using value_type = IndexType; + using difference_type = std::ptrdiff_t; + using pointer = value_type*; + using reference = value_type&; using index_type = value_type; using index_size_type = typename IndexType::value_type; template @@ -996,7 +996,7 @@ bounds_iterator operator+(typename bounds_iterator::differ namespace details { template - inline constexpr std::enable_if_t< + constexpr std::enable_if_t< std::is_same::value, typename Bounds::index_type> make_stride(const Bounds& bnd) GSL_NOEXCEPT @@ -1006,7 +1006,7 @@ namespace details // Make a stride vector from bounds, assuming contiguous memory. template - inline constexpr std::enable_if_t< + constexpr std::enable_if_t< std::is_same::value, typename Bounds::index_type> make_stride(const Bounds& bnd) GSL_NOEXCEPT @@ -1052,17 +1052,17 @@ struct dim_t { static const std::ptrdiff_t value = dynamic_range; const std::ptrdiff_t dvalue; - dim_t(std::ptrdiff_t size) : dvalue(size) {} + constexpr dim_t(std::ptrdiff_t size) GSL_NOEXCEPT : dvalue(size) {} }; template = 0)>> -inline constexpr dim_t dim() GSL_NOEXCEPT +constexpr dim_t dim() GSL_NOEXCEPT { return dim_t(); } template > -inline constexpr dim_t dim(std::ptrdiff_t n) GSL_NOEXCEPT +constexpr dim_t dim(std::ptrdiff_t n) GSL_NOEXCEPT { return dim_t<>(n); } @@ -1070,7 +1070,6 @@ inline constexpr dim_t dim(std::ptrdiff_t n) GSL_NOEXCEPT template class multi_span; - template class strided_span; @@ -1479,15 +1478,15 @@ public: constexpr pointer data() const GSL_NOEXCEPT { return data_; } template - constexpr reference operator()(FirstIndex index) + constexpr reference operator()(FirstIndex idx) { - return this->operator[](narrow_cast(index)); + return this->operator[](narrow_cast(idx)); } template - constexpr reference operator()(FirstIndex index, OtherIndices... indices) + constexpr reference operator()(FirstIndex firstIndex, OtherIndices... indices) { - index_type idx = {narrow_cast(index), + index_type idx = {narrow_cast(firstIndex), narrow_cast(indices)...}; return this->operator[](idx); } @@ -1600,7 +1599,7 @@ public: // DimCount and Enabled here are workarounds for a bug in MSVC 2015 template 0), typename = std::enable_if_t> -inline constexpr auto as_multi_span(SpanType s, Dimensions2... dims) +constexpr auto as_multi_span(SpanType s, Dimensions2... dims) -> multi_span { static_assert(details::is_multi_span::value, @@ -1638,7 +1637,7 @@ multi_span as_writeable_bytes(multi_span s) GSL_NOEXCEPT // on all implementations. It should be considered an experimental extension // to the standard GSL interface. template -inline constexpr auto +constexpr auto as_multi_span(multi_span s) GSL_NOEXCEPT -> multi_span< const U, static_cast( multi_span::bounds_type::static_size != dynamic_range @@ -1665,7 +1664,7 @@ as_multi_span(multi_span s) GSL_NOEXCEPT -> multi_spa // on all implementations. It should be considered an experimental extension // to the standard GSL interface. template -inline constexpr auto as_multi_span(multi_span s) GSL_NOEXCEPT +constexpr auto as_multi_span(multi_span s) GSL_NOEXCEPT -> multi_span( multi_span::bounds_type::static_size != dynamic_range ? static_cast( @@ -1686,7 +1685,7 @@ inline constexpr auto as_multi_span(multi_span s) GSL_NOEXC } template -inline constexpr auto as_multi_span(T* const& ptr, dim_t... args) +constexpr auto as_multi_span(T* const& ptr, dim_t... args) -> multi_span, Dimensions...> { return {reinterpret_cast*>(ptr), @@ -1695,41 +1694,41 @@ inline constexpr auto as_multi_span(T* const& ptr, dim_t... args) } template -inline constexpr auto as_multi_span(T* arr, std::ptrdiff_t len) -> +constexpr auto as_multi_span(T* arr, std::ptrdiff_t len) -> typename details::SpanArrayTraits::type { return {reinterpret_cast*>(arr), len}; } template -inline constexpr auto as_multi_span(T (&arr)[N]) -> typename details::SpanArrayTraits::type +constexpr auto as_multi_span(T (&arr)[N]) -> typename details::SpanArrayTraits::type { return {arr}; } template -inline constexpr multi_span as_multi_span(const std::array& arr) +constexpr multi_span as_multi_span(const std::array& arr) { return {arr}; } template -inline constexpr multi_span as_multi_span(const std::array&&) = delete; +constexpr multi_span as_multi_span(const std::array&&) = delete; template -inline constexpr multi_span as_multi_span(std::array& arr) +constexpr multi_span as_multi_span(std::array& arr) { return {arr}; } template -inline constexpr multi_span as_multi_span(T* begin, T* end) +constexpr multi_span as_multi_span(T* begin, T* end) { return {begin, end}; } template -inline constexpr auto as_multi_span(Cont& arr) -> std::enable_if_t< +constexpr auto as_multi_span(Cont& arr) -> std::enable_if_t< !details::is_multi_span>::value, multi_span, dynamic_range>> { @@ -1738,13 +1737,13 @@ inline constexpr auto as_multi_span(Cont& arr) -> std::enable_if_t< } template -inline constexpr auto as_multi_span(Cont&& arr) -> std::enable_if_t< +constexpr auto as_multi_span(Cont&& arr) -> std::enable_if_t< !details::is_multi_span>::value, multi_span, dynamic_range>> = delete; // from basic_string which doesn't have nonconst .data() member like other contiguous containers template -inline constexpr auto as_multi_span(std::basic_string& str) +constexpr auto as_multi_span(std::basic_string& str) -> multi_span { Expects(str.size() < PTRDIFF_MAX); @@ -1996,14 +1995,13 @@ private: template class contiguous_span_iterator - : public std::iterator { - using Base = std::iterator; - public: - using typename Base::reference; - using typename Base::pointer; - using typename Base::difference_type; + using iterator_category = std::random_access_iterator_tag; + using value_type = typename Span::value_type; + using difference_type = std::ptrdiff_t; + using pointer = value_type*; + using reference = value_type&; private: template @@ -2116,15 +2114,13 @@ contiguous_span_iterator operator+(typename contiguous_span_iterator template class general_span_iterator - : public std::iterator { - using Base = std::iterator; - public: - using typename Base::reference; - using typename Base::pointer; - using typename Base::difference_type; - using typename Base::value_type; + using iterator_category = std::random_access_iterator_tag; + using value_type = typename Span::value_type; + using difference_type = std::ptrdiff_t; + using pointer = value_type*; + using reference = value_type&; private: template diff --git a/Telegram/ThirdParty/GSL/include/gsl/pointers b/Telegram/ThirdParty/GSL/include/gsl/pointers index 1c91e52d3..b2804a315 100644 --- a/Telegram/ThirdParty/GSL/include/gsl/pointers +++ b/Telegram/ThirdParty/GSL/include/gsl/pointers @@ -17,11 +17,13 @@ #ifndef GSL_POINTERS_H #define GSL_POINTERS_H -#include +#include // for Ensures, Expects -#include -#include -#include +#include // for forward +#include // for ptrdiff_t, nullptr_t, ostream, size_t +#include // for shared_ptr, unique_ptr +#include // for hash +#include // for enable_if_t, is_convertible, is_assignable #if defined(_MSC_VER) && _MSC_VER < 1910 #pragma push_macro("constexpr") @@ -80,6 +82,7 @@ public: { } + not_null(not_null&& other) = default; not_null(const not_null& other) = default; not_null& operator=(const not_null& other) = default; diff --git a/Telegram/ThirdParty/GSL/include/gsl/span b/Telegram/ThirdParty/GSL/include/gsl/span index 98fe76840..622c0318e 100644 --- a/Telegram/ThirdParty/GSL/include/gsl/span +++ b/Telegram/ThirdParty/GSL/include/gsl/span @@ -17,16 +17,17 @@ #ifndef GSL_SPAN_H #define GSL_SPAN_H -#include -#include -#include +#include // for Expects +#include // for byte +#include // for narrow_cast, narrow -#include -#include +#include // for lexicographical_compare +#include // for array +#include // for ptrdiff_t, size_t, nullptr_t +#include // for reverse_iterator, distance, random_access_... #include -#include #include -#include +#include // for enable_if_t, declval, is_convertible, inte... #include #ifdef _MSC_VER @@ -44,15 +45,20 @@ #if _MSC_VER < 1910 #pragma push_macro("constexpr") #define constexpr /*constexpr*/ +#define GSL_USE_STATIC_CONSTEXPR_WORKAROUND #endif // _MSC_VER < 1910 +#else // _MSC_VER + +// See if we have enough C++17 power to use a static constexpr data member +// without needing an out-of-line definition +#if !(defined(__cplusplus) && (__cplusplus >= 201703L)) +#define GSL_USE_STATIC_CONSTEXPR_WORKAROUND +#endif // !(defined(__cplusplus) && (__cplusplus >= 201703L)) + #endif // _MSC_VER -#ifdef GSL_THROW_ON_CONTRACT_VIOLATION -#define GSL_NOEXCEPT /*noexcept*/ -#else #define GSL_NOEXCEPT noexcept -#endif // GSL_THROW_ON_CONTRACT_VIOLATION namespace gsl { @@ -115,6 +121,12 @@ namespace details using element_type_ = typename Span::element_type; public: + +#ifdef _MSC_VER + // Tell Microsoft standard library that span_iterators are checked. + using _Unchecked_type = typename Span::pointer; +#endif + using iterator_category = std::random_access_iterator_tag; using value_type = std::remove_cv_t; using difference_type = typename Span::index_type; @@ -124,11 +136,9 @@ namespace details span_iterator() = default; - constexpr span_iterator(const Span* span, typename Span::index_type index) GSL_NOEXCEPT - : span_(span), index_(index) - { - Expects(span == nullptr || (0 <= index_ && index <= span_->length())); - } + constexpr span_iterator(const Span* span, typename Span::index_type idx) GSL_NOEXCEPT + : span_(span), index_(idx) + {} friend span_iterator; template* = nullptr> @@ -137,111 +147,110 @@ namespace details { } - constexpr reference operator*() const GSL_NOEXCEPT + constexpr reference operator*() const { - Expects(index_ != span_->length()); + Expects(index_ != span_->size()); return *(span_->data() + index_); } - constexpr pointer operator->() const GSL_NOEXCEPT + constexpr pointer operator->() const { - Expects(index_ != span_->length()); + Expects(index_ != span_->size()); return span_->data() + index_; } - constexpr span_iterator& operator++() GSL_NOEXCEPT + constexpr span_iterator& operator++() { - Expects(0 <= index_ && index_ != span_->length()); + Expects(0 <= index_ && index_ != span_->size()); ++index_; return *this; } - constexpr span_iterator operator++(int) GSL_NOEXCEPT + constexpr span_iterator operator++(int) { auto ret = *this; ++(*this); return ret; } - constexpr span_iterator& operator--() GSL_NOEXCEPT + constexpr span_iterator& operator--() { - Expects(index_ != 0 && index_ <= span_->length()); + Expects(index_ != 0 && index_ <= span_->size()); --index_; return *this; } - constexpr span_iterator operator--(int) GSL_NOEXCEPT + constexpr span_iterator operator--(int) { auto ret = *this; --(*this); return ret; } - constexpr span_iterator operator+(difference_type n) const GSL_NOEXCEPT + constexpr span_iterator operator+(difference_type n) const { auto ret = *this; return ret += n; } - constexpr span_iterator& operator+=(difference_type n) GSL_NOEXCEPT + constexpr span_iterator& operator+=(difference_type n) { - Expects((index_ + n) >= 0 && (index_ + n) <= span_->length()); + Expects((index_ + n) >= 0 && (index_ + n) <= span_->size()); index_ += n; return *this; } - constexpr span_iterator operator-(difference_type n) const GSL_NOEXCEPT + constexpr span_iterator operator-(difference_type n) const { auto ret = *this; return ret -= n; } - constexpr span_iterator& operator-=(difference_type n) GSL_NOEXCEPT { return *this += -n; } + constexpr span_iterator& operator-=(difference_type n) { return *this += -n; } - constexpr difference_type operator-(const span_iterator& rhs) const GSL_NOEXCEPT + constexpr difference_type operator-(span_iterator rhs) const { Expects(span_ == rhs.span_); return index_ - rhs.index_; } - constexpr reference operator[](difference_type n) const GSL_NOEXCEPT + constexpr reference operator[](difference_type n) const { return *(*this + n); } - constexpr friend bool operator==(const span_iterator& lhs, - const span_iterator& rhs) GSL_NOEXCEPT + constexpr friend bool operator==(span_iterator lhs, + span_iterator rhs) GSL_NOEXCEPT { return lhs.span_ == rhs.span_ && lhs.index_ == rhs.index_; } - constexpr friend bool operator!=(const span_iterator& lhs, - const span_iterator& rhs) GSL_NOEXCEPT + constexpr friend bool operator!=(span_iterator lhs, + span_iterator rhs) GSL_NOEXCEPT { return !(lhs == rhs); } - constexpr friend bool operator<(const span_iterator& lhs, - const span_iterator& rhs) GSL_NOEXCEPT + constexpr friend bool operator<(span_iterator lhs, + span_iterator rhs) GSL_NOEXCEPT { - Expects(lhs.span_ == rhs.span_); return lhs.index_ < rhs.index_; } - constexpr friend bool operator<=(const span_iterator& lhs, - const span_iterator& rhs) GSL_NOEXCEPT + constexpr friend bool operator<=(span_iterator lhs, + span_iterator rhs) GSL_NOEXCEPT { return !(rhs < lhs); } - constexpr friend bool operator>(const span_iterator& lhs, - const span_iterator& rhs) GSL_NOEXCEPT + constexpr friend bool operator>(span_iterator lhs, + span_iterator rhs) GSL_NOEXCEPT { return rhs < lhs; } - constexpr friend bool operator>=(const span_iterator& lhs, - const span_iterator& rhs) GSL_NOEXCEPT + constexpr friend bool operator>=(span_iterator lhs, + span_iterator rhs) GSL_NOEXCEPT { return !(rhs > lhs); } @@ -252,17 +261,17 @@ namespace details }; template - inline constexpr span_iterator + constexpr span_iterator operator+(typename span_iterator::difference_type n, - const span_iterator& rhs) GSL_NOEXCEPT + span_iterator rhs) { return rhs + n; } template - inline constexpr span_iterator + constexpr span_iterator operator-(typename span_iterator::difference_type n, - const span_iterator& rhs) GSL_NOEXCEPT + span_iterator rhs) { return rhs - n; } @@ -308,6 +317,12 @@ namespace details private: index_type size_; }; + + template + struct calculate_subspan_type + { + using type = span; + }; } // namespace details // [span], class template span @@ -329,7 +344,11 @@ public: using size_type = index_type; - constexpr static const index_type extent = Extent; +#if defined(GSL_USE_STATIC_CONSTEXPR_WORKAROUND) + static constexpr const index_type extent { Extent }; +#else + static constexpr index_type extent { Extent }; +#endif // [span.cons], span constructors, copy, assignment, and destructor template > - constexpr span(const std::unique_ptr& ptr, index_type count) - : storage_(ptr.get(), count) - { - } - - constexpr span(const std::unique_ptr& ptr) : storage_(ptr.get(), ptr.get() ? 1 : 0) - { - } - constexpr span(const std::shared_ptr& ptr) : storage_(ptr.get(), ptr.get() ? 1 : 0) - { - } - // NB: the SFINAE here uses .data() as a incomplete/imperfect proxy for the requirement // on Container to be a contiguous sequence container. template ::value && - details::is_allowed_element_type_conversion::value>> - constexpr span(span&& other) - : storage_(other.data(), details::extent_type(other.size())) - { - } - ~span() GSL_NOEXCEPT = default; constexpr span& operator=(const span& other) GSL_NOEXCEPT = default; - - constexpr span& operator=(span&& other) GSL_NOEXCEPT = default; - + // [span.sub], span subviews template constexpr span first() const @@ -446,7 +437,7 @@ public: } template - constexpr span subspan() const + constexpr auto subspan() const -> typename details::calculate_subspan_type::type { Expects((Offset >= 0 && size() - Offset >= 0) && (Count == dynamic_extent || (Count >= 0 && Offset + Count <= size()))); @@ -473,9 +464,7 @@ public: // [span.obs], span observers - constexpr index_type length() const GSL_NOEXCEPT { return size(); } constexpr index_type size() const GSL_NOEXCEPT { return storage_.size(); } - constexpr index_type length_bytes() const GSL_NOEXCEPT { return size_bytes(); } constexpr index_type size_bytes() const GSL_NOEXCEPT { return size() * narrow_cast(sizeof(element_type)); @@ -494,17 +483,17 @@ public: constexpr pointer data() const GSL_NOEXCEPT { return storage_.data(); } // [span.iter], span iterator support - iterator begin() const GSL_NOEXCEPT { return {this, 0}; } - iterator end() const GSL_NOEXCEPT { return {this, length()}; } + constexpr iterator begin() const GSL_NOEXCEPT { return {this, 0}; } + constexpr iterator end() const GSL_NOEXCEPT { return {this, size()}; } - const_iterator cbegin() const GSL_NOEXCEPT { return {this, 0}; } - const_iterator cend() const GSL_NOEXCEPT { return {this, length()}; } + constexpr const_iterator cbegin() const GSL_NOEXCEPT { return {this, 0}; } + constexpr const_iterator cend() const GSL_NOEXCEPT { return {this, size()}; } - reverse_iterator rbegin() const GSL_NOEXCEPT { return reverse_iterator{end()}; } - reverse_iterator rend() const GSL_NOEXCEPT { return reverse_iterator{begin()}; } + constexpr reverse_iterator rbegin() const GSL_NOEXCEPT { return reverse_iterator{end()}; } + constexpr reverse_iterator rend() const GSL_NOEXCEPT { return reverse_iterator{begin()}; } - const_reverse_iterator crbegin() const GSL_NOEXCEPT { return const_reverse_iterator{cend()}; } - const_reverse_iterator crend() const GSL_NOEXCEPT { return const_reverse_iterator{cbegin()}; } + constexpr const_reverse_iterator crbegin() const GSL_NOEXCEPT { return const_reverse_iterator{cend()}; } + constexpr const_reverse_iterator crend() const GSL_NOEXCEPT { return const_reverse_iterator{cbegin()}; } private: // this implementation detail class lets us take advantage of the @@ -540,7 +529,7 @@ private: template span make_subspan(index_type offset, index_type count, - subspan_selector) const GSL_NOEXCEPT + subspan_selector) const { span tmp(*this); return tmp.subspan(offset, count); @@ -548,7 +537,7 @@ private: span make_subspan(index_type offset, index_type count, - subspan_selector) const GSL_NOEXCEPT + subspan_selector) const { Expects(offset >= 0 && size() - offset >= 0); if (count == dynamic_extent) @@ -561,46 +550,51 @@ private: } }; +#if defined(GSL_USE_STATIC_CONSTEXPR_WORKAROUND) +template +constexpr const typename span::index_type span::extent; +#endif + // [span.comparison], span comparison operators template -inline constexpr bool operator==(const span& l, - const span& r) +constexpr bool operator==(span l, + span r) { return std::equal(l.begin(), l.end(), r.begin(), r.end()); } template -inline constexpr bool operator!=(const span& l, - const span& r) +constexpr bool operator!=(span l, + span r) { return !(l == r); } template -inline constexpr bool operator<(const span& l, - const span& r) +constexpr bool operator<(span l, + span r) { return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end()); } template -inline constexpr bool operator<=(const span& l, - const span& r) +constexpr bool operator<=(span l, + span r) { return !(l > r); } template -inline constexpr bool operator>(const span& l, - const span& r) +constexpr bool operator>(span l, + span r) { return r < l; } template -inline constexpr bool operator>=(const span& l, - const span& r) +constexpr bool operator>=(span l, + span r) { return !(l < r); } @@ -648,53 +642,53 @@ as_writeable_bytes(span s) GSL_NOEXCEPT // make_span() - Utility functions for creating spans // template -span make_span(ElementType* ptr, typename span::index_type count) +constexpr span make_span(ElementType* ptr, typename span::index_type count) { return span(ptr, count); } template -span make_span(ElementType* firstElem, ElementType* lastElem) +constexpr span make_span(ElementType* firstElem, ElementType* lastElem) { return span(firstElem, lastElem); } template -span make_span(ElementType (&arr)[N]) +constexpr span make_span(ElementType (&arr)[N]) GSL_NOEXCEPT { return span(arr); } template -span make_span(Container& cont) +constexpr span make_span(Container& cont) { return span(cont); } template -span make_span(const Container& cont) +constexpr span make_span(const Container& cont) { return span(cont); } template -span make_span(Ptr& cont, std::ptrdiff_t count) +constexpr span make_span(Ptr& cont, std::ptrdiff_t count) { return span(cont, count); } template -span make_span(Ptr& cont) +constexpr span make_span(Ptr& cont) { return span(cont); } // Specialization of gsl::at for span template -inline constexpr ElementType& at(const span& s, std::ptrdiff_t index) +constexpr ElementType& at(span s, index i) { // No bounds checking here because it is done in span::operator[] called below - return s[index]; + return s[i]; } } // namespace gsl diff --git a/Telegram/ThirdParty/GSL/include/gsl/string_span b/Telegram/ThirdParty/GSL/include/gsl/string_span index f6fe4ebcb..e4b186f91 100644 --- a/Telegram/ThirdParty/GSL/include/gsl/string_span +++ b/Telegram/ThirdParty/GSL/include/gsl/string_span @@ -17,13 +17,17 @@ #ifndef GSL_STRING_SPAN_H #define GSL_STRING_SPAN_H -#include -#include -#include +#include // for Ensures, Expects +#include // for narrow_cast +#include // for operator!=, operator==, dynamic_extent -#include +#include // for equal, lexicographical_compare +#include // for array +#include // for ptrdiff_t, size_t, nullptr_t +#include // for PTRDIFF_MAX #include -#include +#include // for basic_string, allocator, char_traits +#include // for declval, is_convertible, enable_if_t, add_... #ifdef _MSC_VER #pragma warning(push) @@ -94,7 +98,7 @@ namespace details { if (str == nullptr || n <= 0) return 0; - span str_span{str, n}; + const span str_span{str, n}; std::ptrdiff_t len = 0; while (len < n && str_span[len]) len++; @@ -126,7 +130,7 @@ span ensure_sentinel(T* seq, std::ptrdiff_t max = PTRDIFF_MAX // the limit of size_type. // template -inline span ensure_z(CharT* const& sz, std::ptrdiff_t max = PTRDIFF_MAX) +span ensure_z(CharT* const& sz, std::ptrdiff_t max = PTRDIFF_MAX) { return ensure_sentinel(sz, max); } @@ -141,7 +145,7 @@ template span::type, dynamic_extent> ensure_z(Cont& cont) { - return ensure_z(cont.data(), static_cast(cont.length())); + return ensure_z(cont.data(), static_cast(cont.size())); } template @@ -190,18 +194,9 @@ public: // copy constexpr basic_string_span(const basic_string_span& other) GSL_NOEXCEPT = default; - // move - constexpr basic_string_span(basic_string_span&& other) GSL_NOEXCEPT = default; - // assign constexpr basic_string_span& operator=(const basic_string_span& other) GSL_NOEXCEPT = default; - // move assign - constexpr basic_string_span& operator=(basic_string_span&& other) GSL_NOEXCEPT = default; - - // from nullptr - constexpr basic_string_span(std::nullptr_t ptr) GSL_NOEXCEPT : span_(ptr) {} - constexpr basic_string_span(pointer ptr, index_type length) : span_(ptr, length) {} constexpr basic_string_span(pointer firstElem, pointer lastElem) : span_(firstElem, lastElem) {} diff --git a/Telegram/ThirdParty/GSL/tests/algorithm_tests.cpp b/Telegram/ThirdParty/GSL/tests/algorithm_tests.cpp index 045fd3e23..388d17d9a 100644 --- a/Telegram/ThirdParty/GSL/tests/algorithm_tests.cpp +++ b/Telegram/ThirdParty/GSL/tests/algorithm_tests.cpp @@ -14,11 +14,17 @@ // /////////////////////////////////////////////////////////////////////////////// -#include +#include // for AssertionHandler, StringRef, CHECK, CHE... -#include +#include // for copy +#include // for span -#include +#include // for array +#include // for size_t + +namespace gsl { +struct fail_fast; +} // namespace gsl using namespace std; using namespace gsl; diff --git a/Telegram/ThirdParty/GSL/tests/assertion_tests.cpp b/Telegram/ThirdParty/GSL/tests/assertion_tests.cpp index 42966d18d..25c008965 100644 --- a/Telegram/ThirdParty/GSL/tests/assertion_tests.cpp +++ b/Telegram/ThirdParty/GSL/tests/assertion_tests.cpp @@ -14,9 +14,9 @@ // /////////////////////////////////////////////////////////////////////////////// -#include +#include // for AssertionHandler, StringRef, CHECK, CHECK... -#include +#include // for fail_fast (ptr only), Ensures, Expects using namespace gsl; diff --git a/Telegram/ThirdParty/GSL/tests/at_tests.cpp b/Telegram/ThirdParty/GSL/tests/at_tests.cpp index 78e8e3dd6..2f9e99975 100644 --- a/Telegram/ThirdParty/GSL/tests/at_tests.cpp +++ b/Telegram/ThirdParty/GSL/tests/at_tests.cpp @@ -14,12 +14,18 @@ // /////////////////////////////////////////////////////////////////////////////// -#include +#include // for AssertionHandler, StringRef, CHECK_THROW... -#include +#include // for at -#include -#include +#include // for array +#include // for size_t +#include // for initializer_list +#include // for vector + +namespace gsl { +struct fail_fast; +} // namespace gsl using gsl::fail_fast; diff --git a/Telegram/ThirdParty/GSL/tests/bounds_tests.cpp b/Telegram/ThirdParty/GSL/tests/bounds_tests.cpp index 51b5393ba..1f4b1e268 100644 --- a/Telegram/ThirdParty/GSL/tests/bounds_tests.cpp +++ b/Telegram/ThirdParty/GSL/tests/bounds_tests.cpp @@ -14,11 +14,15 @@ // /////////////////////////////////////////////////////////////////////////////// -#include +#include // for AssertionHandler, StringRef, TEST_CASE -#include +#include // for static_bounds, static_bounds_dynamic_range_t -#include +#include // for ptrdiff_t, size_t + +namespace gsl { +struct fail_fast; +} // namespace gsl using namespace std; using namespace gsl; diff --git a/Telegram/ThirdParty/GSL/tests/byte_tests.cpp b/Telegram/ThirdParty/GSL/tests/byte_tests.cpp index 2c6259d9f..41501cee9 100644 --- a/Telegram/ThirdParty/GSL/tests/byte_tests.cpp +++ b/Telegram/ThirdParty/GSL/tests/byte_tests.cpp @@ -14,16 +14,9 @@ // /////////////////////////////////////////////////////////////////////////////// -#include +#include // for AssertionHandler, StringRef, CHECK, TEST_... -#include - -#include -#include -#include -#include -#include -#include +#include // for to_byte, to_integer, byte, operator&, ope... using namespace std; using namespace gsl; diff --git a/Telegram/ThirdParty/GSL/tests/multi_span_tests.cpp b/Telegram/ThirdParty/GSL/tests/multi_span_tests.cpp index af58d767e..549dcbeff 100644 --- a/Telegram/ThirdParty/GSL/tests/multi_span_tests.cpp +++ b/Telegram/ThirdParty/GSL/tests/multi_span_tests.cpp @@ -14,16 +14,24 @@ // /////////////////////////////////////////////////////////////////////////////// -#include +#include // for AssertionHandler, StringRef, CHECK, CHECK... -#include +#include // for byte +#include // for narrow_cast +#include // for multi_span, contiguous_span_iterator, dim -#include -#include -#include -#include -#include -#include +#include // for fill, for_each +#include // for array +#include // for ptrdiff_t, size_t +#include // for reverse_iterator, begin, end, operator!= +#include // for iota +#include // for ptrdiff_t +#include // for string +#include // for vector + +namespace gsl { +struct fail_fast; +} // namespace gsl using namespace std; using namespace gsl; @@ -1235,7 +1243,7 @@ TEST_CASE("empty_spans") { multi_span empty_av(nullptr); - CHECK(empty_av.bounds().index_bounds() == index<1>{0}); + CHECK(empty_av.bounds().index_bounds() == multi_span_index<1>{0}); CHECK_THROWS_AS(empty_av[0], fail_fast); CHECK_THROWS_AS(empty_av.begin()[0], fail_fast); CHECK_THROWS_AS(empty_av.cbegin()[0], fail_fast); @@ -1247,7 +1255,7 @@ TEST_CASE("empty_spans") { multi_span empty_av = {}; - CHECK(empty_av.bounds().index_bounds() == index<1>{0}); + CHECK(empty_av.bounds().index_bounds() == multi_span_index<1>{0}); CHECK_THROWS_AS(empty_av[0], fail_fast); CHECK_THROWS_AS(empty_av.begin()[0], fail_fast); CHECK_THROWS_AS(empty_av.cbegin()[0], fail_fast); @@ -1269,13 +1277,13 @@ TEST_CASE("index_constructor") multi_span av(arr, 8); ptrdiff_t a[1] = {0}; - index<1> i = a; + multi_span_index<1> i = a; CHECK(av[i] == 4); auto av2 = as_multi_span(av, dim<4>(), dim(2)); ptrdiff_t a2[2] = {0, 1}; - index<2> i2 = a2; + multi_span_index<2> i2 = a2; CHECK(av2[i2] == 0); CHECK(av2[0][i] == 4); @@ -1287,70 +1295,70 @@ TEST_CASE("index_constructors") { { // components of the same type - index<3> i1(0, 1, 2); + multi_span_index<3> i1(0, 1, 2); CHECK(i1[0] == 0); // components of different types std::size_t c0 = 0; std::size_t c1 = 1; - index<3> i2(c0, c1, 2); + multi_span_index<3> i2(c0, c1, 2); CHECK(i2[0] == 0); // from array - index<3> i3 = {0, 1, 2}; + multi_span_index<3> i3 = {0, 1, 2}; CHECK(i3[0] == 0); // from other index of the same size type - index<3> i4 = i3; + multi_span_index<3> i4 = i3; CHECK(i4[0] == 0); // default - index<3> i7; + multi_span_index<3> i7; CHECK(i7[0] == 0); // default - index<3> i9 = {}; + multi_span_index<3> i9 = {}; CHECK(i9[0] == 0); } { // components of the same type - index<1> i1(0); + multi_span_index<1> i1(0); CHECK(i1[0] == 0); // components of different types std::size_t c0 = 0; - index<1> i2(c0); + multi_span_index<1> i2(c0); CHECK(i2[0] == 0); // from array - index<1> i3 = {0}; + multi_span_index<1> i3 = {0}; CHECK(i3[0] == 0); // from int - index<1> i4 = 0; + multi_span_index<1> i4 = 0; CHECK(i4[0] == 0); // from other index of the same size type - index<1> i5 = i3; + multi_span_index<1> i5 = i3; CHECK(i5[0] == 0); // default - index<1> i8; + multi_span_index<1> i8; CHECK(i8[0] == 0); // default - index<1> i9 = {}; + multi_span_index<1> i9 = {}; CHECK(i9[0] == 0); } #ifdef CONFIRM_COMPILATION_ERRORS { - index<3> i1(0, 1); - index<3> i2(0, 1, 2, 3); - index<3> i3 = {0}; - index<3> i4 = {0, 1, 2, 3}; - index<1> i5 = {0, 1}; + multi_span_index<3> i1(0, 1); + multi_span_index<3> i2(0, 1, 2, 3); + multi_span_index<3> i3 = {0}; + multi_span_index<3> i4 = {0, 1, 2, 3}; + multi_span_index<1> i5 = {0, 1}; } #endif } @@ -1359,15 +1367,15 @@ TEST_CASE("index_operations") { ptrdiff_t a[3] = {0, 1, 2}; ptrdiff_t b[3] = {3, 4, 5}; - index<3> i = a; - index<3> j = b; + multi_span_index<3> i = a; + multi_span_index<3> j = b; CHECK(i[0] == 0); CHECK(i[1] == 1); CHECK(i[2] == 2); { - index<3> k = i + j; + multi_span_index<3> k = i + j; CHECK(i[0] == 0); CHECK(i[1] == 1); @@ -1378,7 +1386,7 @@ TEST_CASE("index_operations") } { - index<3> k = i * 3; + multi_span_index<3> k = i * 3; CHECK(i[0] == 0); CHECK(i[1] == 1); @@ -1389,7 +1397,7 @@ TEST_CASE("index_operations") } { - index<3> k = 3 * i; + multi_span_index<3> k = 3 * i; CHECK(i[0] == 0); CHECK(i[1] == 1); @@ -1400,7 +1408,7 @@ TEST_CASE("index_operations") } { - index<2> k = details::shift_left(i); + multi_span_index<2> k = details::shift_left(i); CHECK(i[0] == 0); CHECK(i[1] == 1); @@ -1423,7 +1431,7 @@ void iterate_second_column(multi_span av) } for (auto i = 0; i < section.size(); ++i) { - auto idx = index<2>{i, 0}; // avoid braces inside the CHECK macro + auto idx = multi_span_index<2>{i, 0}; // avoid braces inside the CHECK macro CHECK(section[idx] == av[i][1]); } @@ -1431,7 +1439,7 @@ void iterate_second_column(multi_span av) CHECK(section.bounds().index_bounds()[1] == 1); for (auto i = 0; i < section.bounds().index_bounds()[0]; ++i) { for (auto j = 0; j < section.bounds().index_bounds()[1]; ++j) { - auto idx = index<2>{i, j}; // avoid braces inside the CHECK macro + auto idx = multi_span_index<2>{i, j}; // avoid braces inside the CHECK macro CHECK(section[idx] == av[i][1]); } } diff --git a/Telegram/ThirdParty/GSL/tests/notnull_tests.cpp b/Telegram/ThirdParty/GSL/tests/notnull_tests.cpp index 6c841f0c5..a7ef27e4b 100644 --- a/Telegram/ThirdParty/GSL/tests/notnull_tests.cpp +++ b/Telegram/ThirdParty/GSL/tests/notnull_tests.cpp @@ -14,13 +14,20 @@ // /////////////////////////////////////////////////////////////////////////////// -#include +#include // for AssertionHandler, StringRef, CHECK, TEST_... -#include +#include // for not_null, operator<, operator<=, operator> -#include -#include -#include +#include // for addressof +#include // for shared_ptr, make_shared, operator<, opera... +#include // for operator<<, ostringstream, basic_ostream:... +#include // for uint16_t +#include // for basic_string, operator==, string, operator<< +#include // for type_info + +namespace gsl { +struct fail_fast; +} // namespace gsl using namespace gsl; @@ -127,6 +134,11 @@ TEST_CASE("TestNotNullConstructors") not_null> x( std::make_shared(10)); // shared_ptr is nullptr assignable + +#ifdef GSL_THROW_ON_CONTRACT_VIOLATION + int* pi = nullptr; + CHECK_THROWS_AS(not_null(pi), fail_fast); +#endif } template @@ -315,3 +327,5 @@ TEST_CASE("TestNotNullCustomPtrComparison") CHECK((NotNull1(p1) >= NotNull2(p2)) == (p1 >= p2)); CHECK((NotNull2(p2) >= NotNull1(p1)) == (p2 >= p1)); } + +static_assert(std::is_nothrow_move_constructible>::value, "not_null must be no-throw move constructible"); diff --git a/Telegram/ThirdParty/GSL/tests/owner_tests.cpp b/Telegram/ThirdParty/GSL/tests/owner_tests.cpp index dbc8d1611..94822f5b3 100644 --- a/Telegram/ThirdParty/GSL/tests/owner_tests.cpp +++ b/Telegram/ThirdParty/GSL/tests/owner_tests.cpp @@ -14,12 +14,9 @@ // /////////////////////////////////////////////////////////////////////////////// -#include +#include // for AssertionHandler, StringRef, CHECK, TEST_... -#include - -#include -#include +#include // for owner using namespace gsl; diff --git a/Telegram/ThirdParty/GSL/tests/span_tests.cpp b/Telegram/ThirdParty/GSL/tests/span_tests.cpp index bc4666b1e..20279ec91 100644 --- a/Telegram/ThirdParty/GSL/tests/span_tests.cpp +++ b/Telegram/ThirdParty/GSL/tests/span_tests.cpp @@ -14,17 +14,25 @@ // /////////////////////////////////////////////////////////////////////////////// -#include +#include // for AssertionHandler, StringRef, CHECK, TEST_... -#include +#include // for byte +#include // for narrow_cast, at +#include // for span, span_iterator, operator==, operator!= -#include -#include -#include -#include -#include -#include -#include +#include // for array +#include // for ptrdiff_t +#include // for reverse_iterator, operator-, operator== +#include // for unique_ptr, shared_ptr, make_unique, allo... +#include // for match_results, sub_match, match_results<>... +#include // for ptrdiff_t +#include // for string +#include // for integral_constant<>::value, is_default_co... +#include // for vector + +namespace gsl { +struct fail_fast; +} // namespace gsl using namespace std; using namespace gsl; @@ -43,33 +51,33 @@ TEST_CASE("default_constructor") { { span s; - CHECK((s.length() == 0 && s.data() == nullptr)); + CHECK((s.size() == 0 && s.data() == nullptr)); span cs; - CHECK((cs.length() == 0 && cs.data() == nullptr)); + CHECK((cs.size() == 0 && cs.data() == nullptr)); } { span s; - CHECK((s.length() == 0 && s.data() == nullptr)); + CHECK((s.size() == 0 && s.data() == nullptr)); span cs; - CHECK((cs.length() == 0 && cs.data() == nullptr)); + CHECK((cs.size() == 0 && cs.data() == nullptr)); } { #ifdef CONFIRM_COMPILATION_ERRORS span s; - CHECK((s.length() == 1 && s.data() == nullptr)); // explains why it can't compile + CHECK((s.size() == 1 && s.data() == nullptr)); // explains why it can't compile #endif } { span s{}; - CHECK((s.length() == 0 && s.data() == nullptr)); + CHECK((s.size() == 0 && s.data() == nullptr)); span cs{}; - CHECK((cs.length() == 0 && cs.data() == nullptr)); + CHECK((cs.size() == 0 && cs.data() == nullptr)); } } @@ -86,64 +94,22 @@ TEST_CASE("size_optimization") } } -TEST_CASE("from_nullptr_constructor") -{ - { - span s = nullptr; - CHECK((s.length() == 0 && s.data() == nullptr)); - - span cs = nullptr; - CHECK((cs.length() == 0 && cs.data() == nullptr)); - } - - { - span s = nullptr; - CHECK((s.length() == 0 && s.data() == nullptr)); - - span cs = nullptr; - CHECK((cs.length() == 0 && cs.data() == nullptr)); - } - - { -#ifdef CONFIRM_COMPILATION_ERRORS - span s = nullptr; - CHECK((s.length() == 1 && s.data() == nullptr)); // explains why it can't compile -#endif - } - - { - span s{nullptr}; - CHECK((s.length() == 0 && s.data() == nullptr)); - - span cs{nullptr}; - CHECK((cs.length() == 0 && cs.data() == nullptr)); - } - - { - span s{nullptr}; - CHECK((s.length() == 0 && s.data() == nullptr)); - - span cs{nullptr}; - CHECK((cs.length() == 0 && cs.data() == nullptr)); - } -} - -TEST_CASE("from_nullptr_length_constructor") +TEST_CASE("from_nullptr_size_constructor") { { span s{nullptr, static_cast::index_type>(0)}; - CHECK((s.length() == 0 && s.data() == nullptr)); + CHECK((s.size() == 0 && s.data() == nullptr)); span cs{nullptr, static_cast::index_type>(0)}; - CHECK((cs.length() == 0 && cs.data() == nullptr)); + CHECK((cs.size() == 0 && cs.data() == nullptr)); } { span s{nullptr, static_cast::index_type>(0)}; - CHECK((s.length() == 0 && s.data() == nullptr)); + CHECK((s.size() == 0 && s.data() == nullptr)); span cs{nullptr, static_cast::index_type>(0)}; - CHECK((cs.length() == 0 && cs.data() == nullptr)); + CHECK((cs.size() == 0 && cs.data() == nullptr)); } { @@ -171,10 +137,10 @@ TEST_CASE("from_nullptr_length_constructor") { span s{nullptr, static_cast::index_type>(0)}; - CHECK((s.length() == 0 && s.data() == nullptr)); + CHECK((s.size() == 0 && s.data() == nullptr)); span cs{nullptr, static_cast::index_type>(0)}; - CHECK((cs.length() == 0 && cs.data() == nullptr)); + CHECK((cs.size() == 0 && cs.data() == nullptr)); } } @@ -187,7 +153,7 @@ TEST_CASE("from_pointer_length_constructor") { { span s = { &arr[0], i }; - CHECK(s.length() == i); + CHECK(s.size() == i); CHECK(s.data() == &arr[0]); CHECK(s.empty() == (i == 0)); for (int j = 0; j < i; ++j) @@ -199,7 +165,7 @@ TEST_CASE("from_pointer_length_constructor") } { span s = { &arr[i], 4-i }; - CHECK(s.length() == 4-i); + CHECK(s.size() == 4-i); CHECK(s.data() == &arr[i]); CHECK(s.empty() == (4-i == 0)); for (int j = 0; j < 4-i; ++j) @@ -214,14 +180,14 @@ TEST_CASE("from_pointer_length_constructor") { span s{&arr[0], 2}; - CHECK((s.length() == 2 && s.data() == &arr[0])); + CHECK((s.size() == 2 && s.data() == &arr[0])); CHECK((s[0] == 1 && s[1] == 2)); } { int* p = nullptr; span s{p, static_cast::index_type>(0)}; - CHECK((s.length() == 0 && s.data() == nullptr)); + CHECK((s.size() == 0 && s.data() == nullptr)); } { @@ -232,14 +198,14 @@ TEST_CASE("from_pointer_length_constructor") { auto s = make_span(&arr[0], 2); - CHECK((s.length() == 2 && s.data() == &arr[0])); + CHECK((s.size() == 2 && s.data() == &arr[0])); CHECK((s[0] == 1 && s[1] == 2)); } { int* p = nullptr; auto s = make_span(p, static_cast::index_type>(0)); - CHECK((s.length() == 0 && s.data() == nullptr)); + CHECK((s.size() == 0 && s.data() == nullptr)); } { @@ -255,24 +221,24 @@ TEST_CASE("from_pointer_pointer_constructor") { span s{&arr[0], &arr[2]}; - CHECK((s.length() == 2 && s.data() == &arr[0])); + CHECK((s.size() == 2 && s.data() == &arr[0])); CHECK((s[0] == 1 && s[1] == 2)); } { span s{&arr[0], &arr[2]}; - CHECK((s.length() == 2 && s.data() == &arr[0])); + CHECK((s.size() == 2 && s.data() == &arr[0])); CHECK((s[0] == 1 && s[1] == 2)); } { span s{&arr[0], &arr[0]}; - CHECK((s.length() == 0 && s.data() == &arr[0])); + CHECK((s.size() == 0 && s.data() == &arr[0])); } { span s{&arr[0], &arr[0]}; - CHECK((s.length() == 0 && s.data() == &arr[0])); + CHECK((s.size() == 0 && s.data() == &arr[0])); } // this will fail the std::distance() precondition, which asserts on MSVC debug builds @@ -291,13 +257,13 @@ TEST_CASE("from_pointer_pointer_constructor") { int* p = nullptr; span s{p, p}; - CHECK((s.length() == 0 && s.data() == nullptr)); + CHECK((s.size() == 0 && s.data() == nullptr)); } { int* p = nullptr; span s{p, p}; - CHECK((s.length() == 0 && s.data() == nullptr)); + CHECK((s.size() == 0 && s.data() == nullptr)); } // this will fail the std::distance() precondition, which asserts on MSVC debug builds @@ -309,19 +275,19 @@ TEST_CASE("from_pointer_pointer_constructor") { auto s = make_span(&arr[0], &arr[2]); - CHECK((s.length() == 2 && s.data() == &arr[0])); + CHECK((s.size() == 2 && s.data() == &arr[0])); CHECK((s[0] == 1 && s[1] == 2)); } { auto s = make_span(&arr[0], &arr[0]); - CHECK((s.length() == 0 && s.data() == &arr[0])); + CHECK((s.size() == 0 && s.data() == &arr[0])); } { int* p = nullptr; auto s = make_span(p, p); - CHECK((s.length() == 0 && s.data() == nullptr)); + CHECK((s.size() == 0 && s.data() == nullptr)); } } @@ -331,12 +297,12 @@ TEST_CASE("from_array_constructor") { span s{arr}; - CHECK((s.length() == 5 && s.data() == &arr[0])); + CHECK((s.size() == 5 && s.data() == &arr[0])); } { span s{arr}; - CHECK((s.length() == 5 && s.data() == &arr[0])); + CHECK((s.size() == 5 && s.data() == &arr[0])); } int arr2d[2][3] = {1, 2, 3, 4, 5, 6}; @@ -348,18 +314,18 @@ TEST_CASE("from_array_constructor") { span s{arr}; - CHECK((s.length() == 0 && s.data() == &arr[0])); + CHECK((s.size() == 0 && s.data() == &arr[0])); } { span s{arr2d}; - CHECK((s.length() == 6 && s.data() == &arr2d[0][0])); + CHECK((s.size() == 6 && s.data() == &arr2d[0][0])); CHECK((s[0] == 1 && s[5] == 6)); } { span s{arr2d}; - CHECK((s.length() == 0 && s.data() == &arr2d[0][0])); + CHECK((s.size() == 0 && s.data() == &arr2d[0][0])); } { @@ -368,7 +334,7 @@ TEST_CASE("from_array_constructor") #endif { span s{&(arr2d[0]), 1}; - CHECK((s.length() == 1 && s.data() == &arr2d[0])); + CHECK((s.size() == 1 && s.data() == &arr2d[0])); } int arr3d[2][3][2] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; @@ -376,13 +342,13 @@ TEST_CASE("from_array_constructor") #ifdef CONFIRM_COMPILATION_ERRORS { span s{arr3d}; - CHECK((s.length() == 12 && s.data() == &arr3d[0][0][0])); + CHECK((s.size() == 12 && s.data() == &arr3d[0][0][0])); CHECK((s[0] == 1 && s[11] == 12)); } { span s{arr3d}; - CHECK((s.length() == 0 && s.data() == &arr3d[0][0][0])); + CHECK((s.size() == 0 && s.data() == &arr3d[0][0][0])); } { @@ -391,28 +357,28 @@ TEST_CASE("from_array_constructor") { span s{arr3d}; - CHECK((s.length() == 12 && s.data() == &arr3d[0][0][0])); + CHECK((s.size() == 12 && s.data() == &arr3d[0][0][0])); CHECK((s[0] == 1 && s[5] == 6)); } #endif { span s{&arr3d[0], 1}; - CHECK((s.length() == 1 && s.data() == &arr3d[0])); + CHECK((s.size() == 1 && s.data() == &arr3d[0])); } { auto s = make_span(arr); - CHECK((s.length() == 5 && s.data() == &arr[0])); + CHECK((s.size() == 5 && s.data() == &arr[0])); } { auto s = make_span(&(arr2d[0]), 1); - CHECK((s.length() == 1 && s.data() == &arr2d[0])); + CHECK((s.size() == 1 && s.data() == &arr2d[0])); } { auto s = make_span(&arr3d[0], 1); - CHECK((s.length() == 1 && s.data() == &arr3d[0])); + CHECK((s.size() == 1 && s.data() == &arr3d[0])); } } @@ -422,12 +388,12 @@ TEST_CASE("from_dynamic_array_constructor") { span s(&arr[0][0][0], 10); - CHECK((s.length() == 10 && s.data() == &arr[0][0][0])); + CHECK((s.size() == 10 && s.data() == &arr[0][0][0])); } { auto s = make_span(&arr[0][0][0], 10); - CHECK((s.length() == 10 && s.data() == &arr[0][0][0])); + CHECK((s.size() == 10 && s.data() == &arr[0][0][0])); } delete[] arr; @@ -578,104 +544,6 @@ TEST_CASE("from_std_array_const_constructor") } } -TEST_CASE("from_unique_pointer_construction") -{ - { - auto ptr = std::make_unique(4); - - { - span s{ptr}; - CHECK((s.length() == 1 && s.data() == ptr.get())); - CHECK(s[0] == 4); - } - - { - auto s = make_span(ptr); - CHECK((s.length() == 1 && s.data() == ptr.get())); - CHECK(s[0] == 4); - } - } - - { - auto ptr = std::unique_ptr{nullptr}; - - { - span s{ptr}; - CHECK((s.length() == 0 && s.data() == nullptr)); - } - - { - auto s = make_span(ptr); - CHECK((s.length() == 0 && s.data() == nullptr)); - } - } - - { - auto arr = std::make_unique(4); - - for (auto i = 0U; i < 4; i++) arr[i] = gsl::narrow_cast(i + 1); - - { - span s{arr, 4}; - CHECK((s.length() == 4 && s.data() == arr.get())); - CHECK((s[0] == 1 && s[1] == 2)); - } - - { - auto s = make_span(arr, 4); - CHECK((s.length() == 4 && s.data() == arr.get())); - CHECK((s[0] == 1 && s[1] == 2)); - } - } - - { - auto arr = std::unique_ptr{nullptr}; - - { - span s{arr, 0}; - CHECK((s.length() == 0 && s.data() == nullptr)); - } - - { - auto s = make_span(arr, 0); - CHECK((s.length() == 0 && s.data() == nullptr)); - } - } -} - -TEST_CASE("from_shared_pointer_construction") -{ - { - auto ptr = std::make_shared(4); - - { - span s{ptr}; - CHECK((s.length() == 1 && s.data() == ptr.get())); - CHECK((s[0] == 4)); - } - - { - auto s = make_span(ptr); - CHECK((s.length() == 1 && s.data() == ptr.get())); - CHECK((s[0] == 4)); - } - } - - { - auto ptr = std::shared_ptr{nullptr}; - - { - span s{ptr}; - CHECK((s.length() == 0 && s.data() == nullptr)); - } - - { - auto s = make_span(ptr); - CHECK((s.length() == 0 && s.data() == nullptr)); - } - } -} - TEST_CASE("from_container_constructor") { std::vector v = {1, 2, 3}; @@ -813,17 +681,17 @@ TEST_CASE("copy_move_and_assignment") int arr[] = {3, 4, 5}; span s2 = arr; - CHECK((s2.length() == 3 && s2.data() == &arr[0])); + CHECK((s2.size() == 3 && s2.data() == &arr[0])); s2 = s1; CHECK(s2.empty()); auto get_temp_span = [&]() -> span { return {&arr[1], 2}; }; - auto use_span = [&](span s) { CHECK((s.length() == 2 && s.data() == &arr[1])); }; + auto use_span = [&](span s) { CHECK((s.size() == 2 && s.data() == &arr[1])); }; use_span(get_temp_span()); s1 = get_temp_span(); - CHECK((s1.length() == 2 && s1.data() == &arr[1])); + CHECK((s1.size() == 2 && s1.data() == &arr[1])); } TEST_CASE("first") @@ -832,35 +700,35 @@ TEST_CASE("first") { span av = arr; - CHECK(av.first<2>().length() == 2); - CHECK(av.first(2).length() == 2); + CHECK(av.first<2>().size() == 2); + CHECK(av.first(2).size() == 2); } { span av = arr; - CHECK(av.first<0>().length() == 0); - CHECK(av.first(0).length() == 0); + CHECK(av.first<0>().size() == 0); + CHECK(av.first(0).size() == 0); } { span av = arr; - CHECK(av.first<5>().length() == 5); - CHECK(av.first(5).length() == 5); + CHECK(av.first<5>().size() == 5); + CHECK(av.first(5).size() == 5); } { span av = arr; #ifdef CONFIRM_COMPILATION_ERRORS - CHECK(av.first<6>().length() == 6); - CHECK(av.first<-1>().length() == -1); + CHECK(av.first<6>().size() == 6); + CHECK(av.first<-1>().size() == -1); #endif - CHECK_THROWS_AS(av.first(6).length(), fail_fast); + CHECK_THROWS_AS(av.first(6).size(), fail_fast); } { span av; - CHECK(av.first<0>().length() == 0); - CHECK(av.first(0).length() == 0); + CHECK(av.first<0>().size() == 0); + CHECK(av.first(0).size() == 0); } } @@ -870,34 +738,34 @@ TEST_CASE("last") { span av = arr; - CHECK(av.last<2>().length() == 2); - CHECK(av.last(2).length() == 2); + CHECK(av.last<2>().size() == 2); + CHECK(av.last(2).size() == 2); } { span av = arr; - CHECK(av.last<0>().length() == 0); - CHECK(av.last(0).length() == 0); + CHECK(av.last<0>().size() == 0); + CHECK(av.last(0).size() == 0); } { span av = arr; - CHECK(av.last<5>().length() == 5); - CHECK(av.last(5).length() == 5); + CHECK(av.last<5>().size() == 5); + CHECK(av.last(5).size() == 5); } { span av = arr; #ifdef CONFIRM_COMPILATION_ERRORS - CHECK(av.last<6>().length() == 6); + CHECK(av.last<6>().size() == 6); #endif - CHECK_THROWS_AS(av.last(6).length(), fail_fast); + CHECK_THROWS_AS(av.last(6).size(), fail_fast); } { span av; - CHECK(av.last<0>().length() == 0); - CHECK(av.last(0).length() == 0); + CHECK(av.last<0>().size() == 0); + CHECK(av.last(0).size() == 0); } } @@ -907,64 +775,76 @@ TEST_CASE("subspan") { span av = arr; - CHECK((av.subspan<2, 2>().length() == 2)); - CHECK(av.subspan(2, 2).length() == 2); - CHECK(av.subspan(2, 3).length() == 3); + CHECK((av.subspan<2, 2>().size() == 2)); + CHECK(decltype(av.subspan<2, 2>())::extent == 2); + CHECK(av.subspan(2, 2).size() == 2); + CHECK(av.subspan(2, 3).size() == 3); } { span av = arr; - CHECK((av.subspan<0, 0>().length() == 0)); - CHECK(av.subspan(0, 0).length() == 0); + CHECK((av.subspan<0, 0>().size() == 0)); + CHECK(decltype(av.subspan<0,0>())::extent == 0); + CHECK(av.subspan(0, 0).size() == 0); } { span av = arr; - CHECK((av.subspan<0, 5>().length() == 5)); - CHECK(av.subspan(0, 5).length() == 5); - CHECK_THROWS_AS(av.subspan(0, 6).length(), fail_fast); - CHECK_THROWS_AS(av.subspan(1, 5).length(), fail_fast); + CHECK((av.subspan<0, 5>().size() == 5)); + CHECK(decltype(av.subspan<0, 5>())::extent == 5); + CHECK(av.subspan(0, 5).size() == 5); + + CHECK_THROWS_AS(av.subspan(0, 6).size(), fail_fast); + CHECK_THROWS_AS(av.subspan(1, 5).size(), fail_fast); } { span av = arr; - CHECK((av.subspan<4, 0>().length() == 0)); - CHECK(av.subspan(4, 0).length() == 0); - CHECK(av.subspan(5, 0).length() == 0); - CHECK_THROWS_AS(av.subspan(6, 0).length(), fail_fast); + CHECK((av.subspan<4, 0>().size() == 0)); + CHECK(decltype(av.subspan<4, 0>())::extent == 0); + CHECK(av.subspan(4, 0).size() == 0); + CHECK(av.subspan(5, 0).size() == 0); + CHECK_THROWS_AS(av.subspan(6, 0).size(), fail_fast); + } + + { + span av = arr; + CHECK((av.subspan<1>().size() == 4)); + CHECK(decltype(av.subspan<1>())::extent == 4); } { span av; - CHECK((av.subspan<0, 0>().length() == 0)); - CHECK(av.subspan(0, 0).length() == 0); - CHECK_THROWS_AS((av.subspan<1, 0>().length()), fail_fast); + CHECK((av.subspan<0, 0>().size() == 0)); + CHECK((decltype(av.subspan<0, 0>())::extent == 0)); + CHECK(av.subspan(0, 0).size() == 0); + CHECK_THROWS_AS((av.subspan<1, 0>().size()), fail_fast); } { span av; - CHECK(av.subspan(0).length() == 0); - CHECK_THROWS_AS(av.subspan(1).length(), fail_fast); + CHECK(av.subspan(0).size() == 0); + CHECK_THROWS_AS(av.subspan(1).size(), fail_fast); } { span av = arr; - CHECK(av.subspan(0).length() == 5); - CHECK(av.subspan(1).length() == 4); - CHECK(av.subspan(4).length() == 1); - CHECK(av.subspan(5).length() == 0); - CHECK_THROWS_AS(av.subspan(6).length(), fail_fast); + CHECK(av.subspan(0).size() == 5); + CHECK(av.subspan(1).size() == 4); + CHECK(av.subspan(4).size() == 1); + CHECK(av.subspan(5).size() == 0); + CHECK_THROWS_AS(av.subspan(6).size(), fail_fast); const auto av2 = av.subspan(1); for (int i = 0; i < 4; ++i) CHECK(av2[i] == i + 2); } { span av = arr; - CHECK(av.subspan(0).length() == 5); - CHECK(av.subspan(1).length() == 4); - CHECK(av.subspan(4).length() == 1); - CHECK(av.subspan(5).length() == 0); - CHECK_THROWS_AS(av.subspan(6).length(), fail_fast); + CHECK(av.subspan(0).size() == 5); + CHECK(av.subspan(1).size() == 4); + CHECK(av.subspan(4).size() == 1); + CHECK(av.subspan(5).size() == 0); + CHECK_THROWS_AS(av.subspan(6).size(), fail_fast); const auto av2 = av.subspan(1); for (int i = 0; i < 4; ++i) CHECK(av2[i] == i + 2); } @@ -1282,8 +1162,8 @@ TEST_CASE("crbegin_crend") TEST_CASE("comparison_operators") { { - span s1 = nullptr; - span s2 = nullptr; + span s1; + span s2; CHECK(s1 == s2); CHECK(!(s1 != s2)); CHECK(!(s1 < s2)); @@ -1320,7 +1200,7 @@ TEST_CASE("comparison_operators") { int arr[] = {2, 1}; // bigger - span s1 = nullptr; + span s1; span s2 = arr; CHECK(s1 != s2); @@ -1405,17 +1285,17 @@ TEST_CASE("as_bytes") { const span s = a; - CHECK(s.length() == 4); + CHECK(s.size() == 4); const span bs = as_bytes(s); CHECK(static_cast(bs.data()) == static_cast(s.data())); - CHECK(bs.length() == s.length_bytes()); + CHECK(bs.size() == s.size_bytes()); } { span s; const auto bs = as_bytes(s); - CHECK(bs.length() == s.length()); - CHECK(bs.length() == 0); + CHECK(bs.size() == s.size()); + CHECK(bs.size() == 0); CHECK(bs.size_bytes() == 0); CHECK(static_cast(bs.data()) == static_cast(s.data())); CHECK(bs.data() == nullptr); @@ -1425,7 +1305,7 @@ TEST_CASE("as_bytes") span s = a; const auto bs = as_bytes(s); CHECK(static_cast(bs.data()) == static_cast(s.data())); - CHECK(bs.length() == s.length_bytes()); + CHECK(bs.size() == s.size_bytes()); } } @@ -1437,18 +1317,18 @@ TEST_CASE("as_writeable_bytes") #ifdef CONFIRM_COMPILATION_ERRORS // you should not be able to get writeable bytes for const objects span s = a; - CHECK(s.length() == 4); + CHECK(s.size() == 4); span bs = as_writeable_bytes(s); CHECK(static_cast(bs.data()) == static_cast(s.data())); - CHECK(bs.length() == s.length_bytes()); + CHECK(bs.size() == s.size_bytes()); #endif } { span s; const auto bs = as_writeable_bytes(s); - CHECK(bs.length() == s.length()); - CHECK(bs.length() == 0); + CHECK(bs.size() == s.size()); + CHECK(bs.size() == 0); CHECK(bs.size_bytes() == 0); CHECK(static_cast(bs.data()) == static_cast(s.data())); CHECK(bs.data() == nullptr); @@ -1458,7 +1338,7 @@ TEST_CASE("as_writeable_bytes") span s = a; const auto bs = as_writeable_bytes(s); CHECK(static_cast(bs.data()) == static_cast(s.data())); - CHECK(bs.length() == s.length_bytes()); + CHECK(bs.size() == s.size_bytes()); } } @@ -1468,12 +1348,12 @@ TEST_CASE("fixed_size_conversions") // converting to an span from an equal size array is ok span s4 = arr; - CHECK(s4.length() == 4); + CHECK(s4.size() == 4); // converting to dynamic_range is always ok { span s = s4; - CHECK(s.length() == s4.length()); + CHECK(s.size() == s4.size()); static_cast(s); } diff --git a/Telegram/ThirdParty/GSL/tests/strided_span_tests.cpp b/Telegram/ThirdParty/GSL/tests/strided_span_tests.cpp index 14400d42e..8719336af 100644 --- a/Telegram/ThirdParty/GSL/tests/strided_span_tests.cpp +++ b/Telegram/ThirdParty/GSL/tests/strided_span_tests.cpp @@ -14,16 +14,21 @@ // /////////////////////////////////////////////////////////////////////////////// -#include +#include // for AssertionHandler, StringRef, CHECK, CHECK... -#include +#include // for byte +#include // for narrow_cast +#include // for strided_span, index, multi_span, strided_... -#include -#include -#include -#include -#include -#include +#include // for size_t +#include // for begin, end +#include // for iota +#include // for integral_constant<>::value, is_convertible +#include // for vector + +namespace gsl { +struct fail_fast; +} // namespace gsl using namespace std; using namespace gsl; @@ -43,8 +48,8 @@ TEST_CASE("span_section_test") int a[30][4][5]; const auto av = as_multi_span(a); - const auto sub = av.section({15, 0, 0}, gsl::index<3>{2, 2, 2}); - const auto subsub = sub.section({1, 0, 0}, gsl::index<3>{1, 1, 1}); + const auto sub = av.section({15, 0, 0}, gsl::multi_span_index<3>{2, 2, 2}); + const auto subsub = sub.section({1, 0, 0}, gsl::multi_span_index<3>{1, 1, 1}); (void) subsub; } @@ -74,18 +79,18 @@ TEST_CASE("strided_span_constructors") const int carr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; strided_span sav1{arr, {{9}, {1}}}; // T -> T - CHECK(sav1.bounds().index_bounds() == index<1>{9}); + CHECK(sav1.bounds().index_bounds() == multi_span_index<1>{9}); CHECK(sav1.bounds().stride() == 1); CHECK((sav1[0] == 1 && sav1[8] == 9)); strided_span sav2{carr, {{4}, {2}}}; // const T -> const T - CHECK(sav2.bounds().index_bounds() == index<1>{4}); - CHECK(sav2.bounds().strides() == index<1>{2}); + CHECK(sav2.bounds().index_bounds() == multi_span_index<1>{4}); + CHECK(sav2.bounds().strides() == multi_span_index<1>{2}); CHECK((sav2[0] == 1 && sav2[3] == 7)); strided_span sav3{arr, {{2, 2}, {6, 2}}}; // T -> const T - CHECK((sav3.bounds().index_bounds() == index<2>{2, 2})); - CHECK((sav3.bounds().strides() == index<2>{6, 2})); + CHECK((sav3.bounds().index_bounds() == multi_span_index<2>{2, 2})); + CHECK((sav3.bounds().strides() == multi_span_index<2>{6, 2})); CHECK((sav3[{0, 0}] == 1 && sav3[{0, 1}] == 3 && sav3[{1, 0}] == 7)); } @@ -98,8 +103,8 @@ TEST_CASE("strided_span_constructors") const multi_span src = arr; strided_span sav{src, {2, 1}}; - CHECK(sav.bounds().index_bounds() == index<1>{2}); - CHECK(sav.bounds().strides() == index<1>{1}); + CHECK(sav.bounds().index_bounds() == multi_span_index<1>{2}); + CHECK(sav.bounds().strides() == multi_span_index<1>{1}); CHECK(sav[1] == 2); #if _MSC_VER > 1800 @@ -110,8 +115,8 @@ TEST_CASE("strided_span_constructors") strided_span sav_c{multi_span{src}, strided_bounds<1>{2, 1}}; #endif - CHECK(sav_c.bounds().index_bounds() == index<1>{2}); - CHECK(sav_c.bounds().strides() == index<1>{1}); + CHECK(sav_c.bounds().index_bounds() == multi_span_index<1>{2}); + CHECK(sav_c.bounds().strides() == multi_span_index<1>{1}); CHECK(sav_c[1] == 2); #if _MSC_VER > 1800 @@ -120,8 +125,8 @@ TEST_CASE("strided_span_constructors") strided_span sav_v{multi_span{src}, strided_bounds<1>{2, 1}}; #endif - CHECK(sav_v.bounds().index_bounds() == index<1>{2}); - CHECK(sav_v.bounds().strides() == index<1>{1}); + CHECK(sav_v.bounds().index_bounds() == multi_span_index<1>{2}); + CHECK(sav_v.bounds().strides() == multi_span_index<1>{1}); CHECK(sav_v[1] == 2); #if _MSC_VER > 1800 @@ -130,8 +135,8 @@ TEST_CASE("strided_span_constructors") strided_span sav_cv{multi_span{src}, strided_bounds<1>{2, 1}}; #endif - CHECK(sav_cv.bounds().index_bounds() == index<1>{2}); - CHECK(sav_cv.bounds().strides() == index<1>{1}); + CHECK(sav_cv.bounds().index_bounds() == multi_span_index<1>{2}); + CHECK(sav_cv.bounds().strides() == multi_span_index<1>{1}); CHECK(sav_cv[1] == 2); } @@ -140,8 +145,8 @@ TEST_CASE("strided_span_constructors") const multi_span src{arr}; strided_span sav_c{src, {2, 1}}; - CHECK(sav_c.bounds().index_bounds() == index<1>{2}); - CHECK(sav_c.bounds().strides() == index<1>{1}); + CHECK(sav_c.bounds().index_bounds() == multi_span_index<1>{2}); + CHECK(sav_c.bounds().strides() == multi_span_index<1>{1}); CHECK(sav_c[1] == 2); #if _MSC_VER > 1800 @@ -151,8 +156,8 @@ TEST_CASE("strided_span_constructors") strided_bounds<1>{2, 1}}; #endif - CHECK(sav_cv.bounds().index_bounds() == index<1>{2}); - CHECK(sav_cv.bounds().strides() == index<1>{1}); + CHECK(sav_cv.bounds().index_bounds() == multi_span_index<1>{2}); + CHECK(sav_cv.bounds().strides() == multi_span_index<1>{1}); CHECK(sav_cv[1] == 2); } @@ -161,8 +166,8 @@ TEST_CASE("strided_span_constructors") const multi_span src{arr}; strided_span sav_v{src, {2, 1}}; - CHECK(sav_v.bounds().index_bounds() == index<1>{2}); - CHECK(sav_v.bounds().strides() == index<1>{1}); + CHECK(sav_v.bounds().index_bounds() == multi_span_index<1>{2}); + CHECK(sav_v.bounds().strides() == multi_span_index<1>{1}); CHECK(sav_v[1] == 2); #if _MSC_VER > 1800 @@ -171,8 +176,8 @@ TEST_CASE("strided_span_constructors") strided_span sav_cv{multi_span{src}, strided_bounds<1>{2, 1}}; #endif - CHECK(sav_cv.bounds().index_bounds() == index<1>{2}); - CHECK(sav_cv.bounds().strides() == index<1>{1}); + CHECK(sav_cv.bounds().index_bounds() == multi_span_index<1>{2}); + CHECK(sav_cv.bounds().strides() == multi_span_index<1>{1}); CHECK(sav_cv[1] == 2); } @@ -181,8 +186,8 @@ TEST_CASE("strided_span_constructors") const multi_span src{arr}; strided_span sav_cv{src, {2, 1}}; - CHECK(sav_cv.bounds().index_bounds() == index<1>{2}); - CHECK(sav_cv.bounds().strides() == index<1>{1}); + CHECK(sav_cv.bounds().index_bounds() == multi_span_index<1>{2}); + CHECK(sav_cv.bounds().strides() == multi_span_index<1>{1}); CHECK(sav_cv[1] == 2); } } @@ -201,7 +206,7 @@ TEST_CASE("strided_span_constructors") const strided_span src{arr, {2, 1}}; strided_span sav{src}; - CHECK(sav.bounds().index_bounds() == index<1>{2}); + CHECK(sav.bounds().index_bounds() == multi_span_index<1>{2}); CHECK(sav.bounds().stride() == 1); CHECK(sav[1] == 5); @@ -216,15 +221,15 @@ TEST_CASE("strided_span_constructors") const strided_span src1{arr1, {2, 1}}; strided_span sav1{src1}; - CHECK(sav1.bounds().index_bounds() == index<1>{2}); + CHECK(sav1.bounds().index_bounds() == multi_span_index<1>{2}); CHECK(sav1.bounds().stride() == 1); CHECK(sav1[0] == 3); int arr2[6] = {1, 2, 3, 4, 5, 6}; const strided_span src2{arr2, {{3, 2}, {2, 1}}}; strided_span sav2{src2}; - CHECK((sav2.bounds().index_bounds() == index<2>{3, 2})); - CHECK((sav2.bounds().strides() == index<2>{2, 1})); + CHECK((sav2.bounds().index_bounds() == multi_span_index<2>{3, 2})); + CHECK((sav2.bounds().strides() == multi_span_index<2>{2, 1})); CHECK((sav2[{0, 0}] == 1 && sav2[{2, 0}] == 5)); } @@ -236,8 +241,8 @@ TEST_CASE("strided_span_constructors") const strided_span src{arr1, {{2}, {1}}}; strided_span sav{arr2, {{3}, {2}}}; strided_span& sav_ref = (sav = src); - CHECK(sav.bounds().index_bounds() == index<1>{2}); - CHECK(sav.bounds().strides() == index<1>{1}); + CHECK(sav.bounds().index_bounds() == multi_span_index<1>{2}); + CHECK(sav.bounds().strides() == multi_span_index<1>{1}); CHECK(sav[0] == 1); CHECK(&sav_ref == &sav); } @@ -249,8 +254,8 @@ TEST_CASE("strided_span_constructors") const strided_span src1{arr1, {2, 1}}; strided_span sav1{arr1b, {1, 1}}; strided_span& sav1_ref = (sav1 = src1); - CHECK(sav1.bounds().index_bounds() == index<1>{2}); - CHECK(sav1.bounds().strides() == index<1>{1}); + CHECK(sav1.bounds().index_bounds() == multi_span_index<1>{2}); + CHECK(sav1.bounds().strides() == multi_span_index<1>{1}); CHECK(sav1[0] == 3); CHECK(&sav1_ref == &sav1); @@ -259,8 +264,8 @@ TEST_CASE("strided_span_constructors") const strided_span src2{arr2, {{3, 2}, {2, 1}}}; strided_span sav2{arr2b, {{1, 1}, {1, 1}}}; strided_span& sav2_ref = (sav2 = src2); - CHECK((sav2.bounds().index_bounds() == index<2>{3, 2})); - CHECK((sav2.bounds().strides() == index<2>{2, 1})); + CHECK((sav2.bounds().index_bounds() == multi_span_index<2>{3, 2})); + CHECK((sav2.bounds().strides() == multi_span_index<2>{2, 1})); CHECK((sav2[{0, 0}] == 1 && sav2[{2, 0}] == 5)); CHECK(&sav2_ref == &sav2); } @@ -317,7 +322,7 @@ TEST_CASE("strided_span_column_major") // Section strided_span cm_sec = cm_sav.section({2, 1}, {3, 2}); - CHECK((cm_sec.bounds().index_bounds() == index<2>{3, 2})); + CHECK((cm_sec.bounds().index_bounds() == multi_span_index<2>{3, 2})); CHECK((cm_sec[{0, 0}] == 8)); CHECK((cm_sec[{0, 1}] == 9)); CHECK((cm_sec[{1, 0}] == 11)); @@ -366,7 +371,7 @@ TEST_CASE("strided_span_bounds") { // strided array ctor with matching strided bounds strided_span sav{arr, {4, 1}}; - CHECK(sav.bounds().index_bounds() == index<1>{4}); + CHECK(sav.bounds().index_bounds() == multi_span_index<1>{4}); CHECK(sav[3] == 3); CHECK_THROWS_AS(sav[4], fail_fast); } @@ -374,7 +379,7 @@ TEST_CASE("strided_span_bounds") { // strided array ctor with smaller strided bounds strided_span sav{arr, {2, 1}}; - CHECK(sav.bounds().index_bounds() == index<1>{2}); + CHECK(sav.bounds().index_bounds() == multi_span_index<1>{2}); CHECK(sav[1] == 1); CHECK_THROWS_AS(sav[2], fail_fast); } @@ -382,7 +387,7 @@ TEST_CASE("strided_span_bounds") { // strided array ctor with fitting irregular bounds strided_span sav{arr, {2, 3}}; - CHECK(sav.bounds().index_bounds() == index<1>{2}); + CHECK(sav.bounds().index_bounds() == multi_span_index<1>{2}); CHECK(sav[0] == 0); CHECK(sav[1] == 3); CHECK_THROWS_AS(sav[2], fail_fast); @@ -428,7 +433,7 @@ TEST_CASE("strided_span_bounds") strided_span sav7{av.as_multi_span(dim<2>(), dim<2>()), {{1, 1}, {1, 1}, {1, 1}}}; - index<1> index{0, 1}; + multi_span_index<1> index{0, 1}; strided_span sav8{arr, {1, {1, 1}}}; strided_span sav9{arr, {{1, 1}, {1, 1}}}; strided_span sav10{av, {1, {1, 1}}}; @@ -543,7 +548,7 @@ TEST_CASE("empty_strided_spans") multi_span empty_av(nullptr); strided_span empty_sav{empty_av, {0, 1}}; - CHECK(empty_sav.bounds().index_bounds() == index<1>{0}); + CHECK(empty_sav.bounds().index_bounds() == multi_span_index<1>{0}); CHECK_THROWS_AS(empty_sav[0], fail_fast); CHECK_THROWS_AS(empty_sav.begin()[0], fail_fast); CHECK_THROWS_AS(empty_sav.cbegin()[0], fail_fast); @@ -557,7 +562,7 @@ TEST_CASE("empty_strided_spans") { strided_span empty_sav{nullptr, 0, {0, 1}}; - CHECK(empty_sav.bounds().index_bounds() == index<1>{0}); + CHECK(empty_sav.bounds().index_bounds() == multi_span_index<1>{0}); CHECK_THROWS_AS(empty_sav[0], fail_fast); CHECK_THROWS_AS(empty_sav.begin()[0], fail_fast); CHECK_THROWS_AS(empty_sav.cbegin()[0], fail_fast); @@ -577,7 +582,7 @@ void iterate_every_other_element(multi_span av) #if _MSC_VER > 1800 auto bounds = strided_bounds<1>({length}, {2}); #else - auto bounds = strided_bounds<1>(index<1>{length}, index<1>{2}); + auto bounds = strided_bounds<1>(multi_span_index<1>{length}, multi_span_index<1>{2}); #endif strided_span strided(&av.data()[1], av.size() - 1, bounds); @@ -633,7 +638,7 @@ void iterate_second_slice(multi_span(); ++i) { for (auto j = 0; j < section.extent<1>(); ++j) for (auto k = 0; k < section.extent<2>(); ++k) { - auto idx = index<3>{i, j, k}; // avoid braces in the CHECK macro + auto idx = multi_span_index<3>{i, j, k}; // avoid braces in the CHECK macro CHECK(section[idx] == expected[2 * i + 2 * j + k]); } } diff --git a/Telegram/ThirdParty/GSL/tests/string_span_tests.cpp b/Telegram/ThirdParty/GSL/tests/string_span_tests.cpp index 823b19dee..0032b0f9d 100644 --- a/Telegram/ThirdParty/GSL/tests/string_span_tests.cpp +++ b/Telegram/ThirdParty/GSL/tests/string_span_tests.cpp @@ -14,15 +14,19 @@ // /////////////////////////////////////////////////////////////////////////////// -#include +#include // for AssertionHandler, StringRef, CHECK, TEST_... -#include //owner -#include +#include // for Expects, fail_fast (ptr only) +#include // for owner +#include // for span, dynamic_extent +#include // for basic_string_span, operator==, ensure_z -#include -#include -#include -#include +#include // for move, find +#include // for size_t +#include // for map +#include // for basic_string, string, char_traits, operat... +#include // for remove_reference<>::type +#include // for vector, allocator using namespace std; using namespace gsl; @@ -507,12 +511,6 @@ TEST_CASE("Constructors") CHECK(span.length() == 0); } - // from nullptr - { - cstring_span<> span(nullptr); - CHECK(span.length() == 0); - } - // from string literal { cstring_span<> span = "Hello"; diff --git a/Telegram/ThirdParty/GSL/tests/utils_tests.cpp b/Telegram/ThirdParty/GSL/tests/utils_tests.cpp index 67cceb5a2..587b0a144 100644 --- a/Telegram/ThirdParty/GSL/tests/utils_tests.cpp +++ b/Telegram/ThirdParty/GSL/tests/utils_tests.cpp @@ -14,14 +14,24 @@ // /////////////////////////////////////////////////////////////////////////////// -#include +#include // for AssertionHandler, StringRef, CHECK, TEST_... -#include +#include // for narrow, finally, narrow_cast, narrowing_e... -#include +#include // for move +#include // for reference_wrapper, _Bind_helper<>::type +#include // for numeric_limits +#include // for uint32_t, int32_t +#include // for is_same using namespace gsl; +TEST_CASE("sanity check for gsl::index typedef") +{ + static_assert(std::is_same::value, + "gsl::index represents wrong arithmetic type"); +} + void f(int& i) { i += 1; } TEST_CASE("finally_lambda")