procxx
/
kepka
mirror of https://github.com/procxx/kepka.git
1
0
Fork 0
Code Issues Releases Wiki Activity

git subrepo pull Telegram/ThirdParty/GSL 

subrepo:
  subdir:   "Telegram/ThirdParty/GSL"
  merged:   "c9e423d7"
upstream:
  origin:   "https://github.com/Microsoft/GSL.git"
  branch:   "master"
  commit:   "c9e423d7"
git-subrepo:
  version:  "0.3.1"
  origin:   "https://github.com/ingydotnet/git-subrepo"
  commit:   "a7ee886"
This commit is contained in:
crackedmind 2018-03-11 03:26:16 +03:00 committed by Alex
parent 7ed116aa9d
commit 9e4a97edf4
25 changed files with 610 additions and 683 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Telegram/ThirdParty/GSL/.gitrepo vendored
View File

@ -6,6 +6,6 @@
[subrepo] [subrepo]
remote = https://github.com/Microsoft/GSL.git remote = https://github.com/Microsoft/GSL.git
branch = master branch = master
commit = 1c95f9436eae69c9b9315911ef6aa210df7d1e31 commit = c9e423d7cf2afb88672e31f55e4b30c53be7aae3
parent = 0dde6bbc3b558644359e5ee49725e508babcea8b parent = dde6ba57a8584fda72b205bd8aff8ce452bdc8de
cmdver = 0.3.1 cmdver = 0.3.1

18
Telegram/ThirdParty/GSL/CMakeLists.txt vendored
View File

@ -1,4 +1,4 @@
cmake_minimum_required(VERSION 3.1.3) cmake_minimum_required(VERSION 3.7)
project(GSL CXX) project(GSL CXX)
@ -16,7 +16,7 @@ endif ()
# when minimum version required is 3.8.0 remove if below # when minimum version required is 3.8.0 remove if below
# both branches do exactly the same thing # 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) if (NOT MSVC)
include(CheckCXXCompilerFlag) include(CheckCXXCompilerFlag)
CHECK_CXX_COMPILER_FLAG("-std=c++14" COMPILER_SUPPORTS_CXX14) 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 # add natvis file to the library so it will automatically be loaded into Visual Studio
target_sources(GSL INTERFACE if(VS_ADD_NATIVE_VISUALIZERS)
${CMAKE_CURRENT_SOURCE_DIR}/GSL.natvis target_sources(GSL INTERFACE
) ${CMAKE_CURRENT_SOURCE_DIR}/GSL.natvis
)
endif()
install( install(
DIRECTORY include/gsl DIRECTORY include/gsl

2
Telegram/ThirdParty/GSL/GSL.natvis vendored
View File

@ -11,7 +11,7 @@
</Type> </Type>
<!-- These types are from the gsl_util header. --> <!-- These types are from the gsl_util header. -->
<Type Name="gsl::final_act&lt;*&gt;"> <Type Name="gsl::final_action&lt;*&gt;">
<DisplayString>{{ invoke = {invoke_}, action = {f_} }}</DisplayString> <DisplayString>{{ invoke = {invoke_}, action = {f_} }}</DisplayString>
<Expand> <Expand>
<Item Name="[invoke]">invoke_</Item> <Item Name="[invoke]">invoke_</Item>

3
Telegram/ThirdParty/GSL/README.md vendored
View File

@ -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 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 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 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 * 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 > 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 ## Building the tests
To build the tests, you will require the following: 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`. These steps assume the source code of this repository has been cloned into a directory named `c:\GSL`.

14
Telegram/ThirdParty/GSL/include/gsl/gsl vendored
View File

@ -17,11 +17,13 @@
#ifndef GSL_GSL_H #ifndef GSL_GSL_H
#define GSL_GSL_H #define GSL_GSL_H
#include <gsl/gsl_assert> // Ensures/Expects #include <gsl/gsl_algorithm> // copy
#include <gsl/gsl_util> // finally()/narrow()/narrow_cast()... #include <gsl/gsl_assert> // Ensures/Expects
#include <gsl/multi_span> // multi_span, strided_span... #include <gsl/gsl_byte> // byte
#include <gsl/span> // span #include <gsl/gsl_util> // finally()/narrow()/narrow_cast()...
#include <gsl/string_span> // zstring, string_span, zstring_builder... #include <gsl/multi_span> // multi_span, strided_span...
#include <gsl/pointers> // owner, not_null #include <gsl/pointers> // owner, not_null
#include <gsl/span> // span
#include <gsl/string_span> // zstring, string_span, zstring_builder...
#endif // GSL_GSL_H #endif // GSL_GSL_H

7
Telegram/ThirdParty/GSL/include/gsl/gsl_algorithm vendored
View File

@ -17,9 +17,12 @@
#ifndef GSL_ALGORITHM_H #ifndef GSL_ALGORITHM_H
#define GSL_ALGORITHM_H #define GSL_ALGORITHM_H
#include <gsl/span> #include <gsl/gsl_assert> // for Expects
#include <gsl/span> // for dynamic_extent, span
#include <algorithm> #include <algorithm> // for copy_n
#include <cstddef> // for ptrdiff_t
#include <type_traits> // for is_assignable
#ifdef _MSC_VER #ifdef _MSC_VER
#pragma warning(push) #pragma warning(push)

6
Telegram/ThirdParty/GSL/include/gsl/gsl_assert vendored
View File

@ -18,7 +18,7 @@
#define GSL_CONTRACTS_H #define GSL_CONTRACTS_H
#include <exception> #include <exception>
#include <stdexcept> #include <stdexcept> // for logic_error
// //
// There are three configuration options for this GSL implementation's behavior // There are three configuration options for this GSL implementation's behavior
@ -52,12 +52,10 @@
// //
#ifdef _MSC_VER #ifdef _MSC_VER
#define GSL_ASSUME(cond) __assume(cond) #define GSL_ASSUME(cond) __assume(cond)
#elif defined(__clang__)
#define GSL_ASSUME(cond) __builtin_assume(cond)
#elif defined(__GNUC__) #elif defined(__GNUC__)
#define GSL_ASSUME(cond) ((cond) ? static_cast<void>(0) : __builtin_unreachable()) #define GSL_ASSUME(cond) ((cond) ? static_cast<void>(0) : __builtin_unreachable())
#else #else
#define GSL_ASSUME(cond) static_cast<void>(!!(cond)) #define GSL_ASSUME(cond) static_cast<void>((cond) ? 0 : 0)
#endif #endif
// //

32
Telegram/ThirdParty/GSL/include/gsl/gsl_byte vendored
View File

@ -74,63 +74,63 @@ enum class byte : unsigned char
}; };
template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>> template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
inline constexpr byte& operator<<=(byte& b, IntegerType shift) noexcept constexpr byte& operator<<=(byte& b, IntegerType shift) noexcept
{ {
return b = byte(static_cast<unsigned char>(b) << shift); return b = byte(static_cast<unsigned char>(b) << shift);
} }
template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>> template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
inline constexpr byte operator<<(byte b, IntegerType shift) noexcept constexpr byte operator<<(byte b, IntegerType shift) noexcept
{ {
return byte(static_cast<unsigned char>(b) << shift); return byte(static_cast<unsigned char>(b) << shift);
} }
template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>> template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
inline constexpr byte& operator>>=(byte& b, IntegerType shift) noexcept constexpr byte& operator>>=(byte& b, IntegerType shift) noexcept
{ {
return b = byte(static_cast<unsigned char>(b) >> shift); return b = byte(static_cast<unsigned char>(b) >> shift);
} }
template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>> template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
inline constexpr byte operator>>(byte b, IntegerType shift) noexcept constexpr byte operator>>(byte b, IntegerType shift) noexcept
{ {
return byte(static_cast<unsigned char>(b) >> shift); return byte(static_cast<unsigned char>(b) >> shift);
} }
inline constexpr byte& operator|=(byte& l, byte r) noexcept constexpr byte& operator|=(byte& l, byte r) noexcept
{ {
return l = byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r)); return l = byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));
} }
inline constexpr byte operator|(byte l, byte r) noexcept constexpr byte operator|(byte l, byte r) noexcept
{ {
return byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r)); return byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));
} }
inline constexpr byte& operator&=(byte& l, byte r) noexcept constexpr byte& operator&=(byte& l, byte r) noexcept
{ {
return l = byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r)); return l = byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
} }
inline constexpr byte operator&(byte l, byte r) noexcept constexpr byte operator&(byte l, byte r) noexcept
{ {
return byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r)); return byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
} }
inline constexpr byte& operator^=(byte& l, byte r) noexcept constexpr byte& operator^=(byte& l, byte r) noexcept
{ {
return l = byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r)); return l = byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
} }
inline constexpr byte operator^(byte l, byte r) noexcept constexpr byte operator^(byte l, byte r) noexcept
{ {
return byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r)); return byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
} }
inline constexpr byte operator~(byte b) noexcept { return byte(~static_cast<unsigned char>(b)); } constexpr byte operator~(byte b) noexcept { return byte(~static_cast<unsigned char>(b)); }
template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>> template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
inline constexpr IntegerType to_integer(byte b) noexcept constexpr IntegerType to_integer(byte b) noexcept
{ {
return static_cast<IntegerType>(b); return static_cast<IntegerType>(b);
} }
@ -138,7 +138,7 @@ inline constexpr IntegerType to_integer(byte b) noexcept
#endif // GSL_USE_STD_BYTE #endif // GSL_USE_STD_BYTE
template <bool E, typename T> template <bool E, typename T>
inline constexpr byte to_byte_impl(T t) noexcept constexpr byte to_byte_impl(T t) noexcept
{ {
static_assert( static_assert(
E, "gsl::to_byte(t) must be provided an unsigned char, otherwise data loss may occur. " 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<byte>(t); return static_cast<byte>(t);
} }
template <> template <>
inline constexpr byte to_byte_impl<true, unsigned char>(unsigned char t) noexcept constexpr byte to_byte_impl<true, unsigned char>(unsigned char t) noexcept
{ {
return byte(t); return byte(t);
} }
template <typename T> template <typename T>
inline constexpr byte to_byte(T t) noexcept constexpr byte to_byte(T t) noexcept
{ {
return to_byte_impl<std::is_same<T, unsigned char>::value, T>(t); return to_byte_impl<std::is_same<T, unsigned char>::value, T>(t);
} }
template <int I> template <int I>
inline constexpr byte to_byte() noexcept constexpr byte to_byte() noexcept
{ {
static_assert(I >= 0 && I <= 255, static_assert(I >= 0 && I <= 255,
"gsl::byte only has 8 bits of storage, values must be in range 0-255"); "gsl::byte only has 8 bits of storage, values must be in range 0-255");

62
Telegram/ThirdParty/GSL/include/gsl/gsl_util vendored
View File

@ -17,12 +17,14 @@
#ifndef GSL_UTIL_H #ifndef GSL_UTIL_H
#define GSL_UTIL_H #define GSL_UTIL_H
#include <gsl/gsl_assert> // Ensures/Expects #include <gsl/gsl_assert> // for Expects
#include <array> #include <array>
#include <exception> #include <cstddef> // for ptrdiff_t, size_t
#include <type_traits> #include <exception> // for exception
#include <utility> #include <initializer_list> // for initializer_list
#include <type_traits> // for is_signed, integral_constant
#include <utility> // for forward
#if defined(_MSC_VER) #if defined(_MSC_VER)
@ -41,47 +43,51 @@ namespace gsl
// GSL.util: utilities // 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 F> template <class F>
class final_act class final_action
{ {
public: 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; other.invoke_ = false;
} }
final_act(const final_act&) = delete; final_action(const final_action&) = delete;
final_act& operator=(const final_act&) = delete; final_action& operator=(const final_action&) = delete;
~final_act() noexcept ~final_action() noexcept
{ {
if (invoke_) f_(); if (invoke_) f_();
} }
private: private:
F f_; F f_;
bool invoke_; bool invoke_ {true};
}; };
// finally() - convenience function to generate a final_act // finally() - convenience function to generate a final_action
template <class F> template <class F>
inline final_act<F> finally(const F& f) noexcept
final_action<F> finally(const F& f) noexcept
{ {
return final_act<F>(f); return final_action<F>(f);
} }
template <class F> template <class F>
inline final_act<F> finally(F&& f) noexcept final_action<F> finally(F&& f) noexcept
{ {
return final_act<F>(std::forward<F>(f)); return final_action<F>(std::forward<F>(f));
} }
// narrow_cast(): a searchable way to do narrowing casts of values // narrow_cast(): a searchable way to do narrowing casts of values
template <class T, class U> template <class T, class U>
inline constexpr T narrow_cast(U&& u) noexcept constexpr T narrow_cast(U&& u) noexcept
{ {
return static_cast<T>(std::forward<U>(u)); return static_cast<T>(std::forward<U>(u));
} }
@ -101,7 +107,7 @@ namespace details
// narrow() : a checked version of narrow_cast() that throws if the cast changed the value // narrow() : a checked version of narrow_cast() that throws if the cast changed the value
template <class T, class U> template <class T, class U>
inline T narrow(U u) T narrow(U u)
{ {
T t = narrow_cast<T>(u); T t = narrow_cast<T>(u);
if (static_cast<U>(t) != u) throw narrowing_error(); if (static_cast<U>(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 // at() - Bounds-checked way of accessing builtin arrays, std::array, std::vector
// //
template <class T, std::size_t N> template <class T, std::size_t N>
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<std::ptrdiff_t>(N)); Expects(i >= 0 && i < narrow_cast<index>(N));
return arr[static_cast<std::size_t>(index)]; return arr[static_cast<std::size_t>(i)];
} }
template <class Cont> template <class Cont>
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<std::ptrdiff_t>(cont.size())); Expects(i >= 0 && i < narrow_cast<index>(cont.size()));
using size_type = decltype(cont.size()); using size_type = decltype(cont.size());
return cont[static_cast<size_type>(index)]; return cont[static_cast<size_type>(i)];
} }
template <class T> template <class T>
inline constexpr T at(const std::initializer_list<T> cont, const std::ptrdiff_t index) constexpr T at(const std::initializer_list<T> cont, const index i)
{ {
Expects(index >= 0 && index < narrow_cast<std::ptrdiff_t>(cont.size())); Expects(i >= 0 && i < narrow_cast<index>(cont.size()));
return *(cont.begin() + index); return *(cont.begin() + i);
} }
} // namespace gsl } // namespace gsl

168
Telegram/ThirdParty/GSL/include/gsl/multi_span vendored
View File

@ -17,22 +17,24 @@
#ifndef GSL_MULTI_SPAN_H #ifndef GSL_MULTI_SPAN_H
#define GSL_MULTI_SPAN_H #define GSL_MULTI_SPAN_H
#include <gsl/gsl_assert> #include <gsl/gsl_assert> // for Expects
#include <gsl/gsl_byte> #include <gsl/gsl_byte> // for byte
#include <gsl/gsl_util> #include <gsl/gsl_util> // for narrow_cast
#include <algorithm> #include <algorithm> // for transform, lexicographical_compare
#include <array> #include <array> // for array
#include <cassert> #include <cassert>
#include <cstddef> #include <cstddef> // for ptrdiff_t, size_t, nullptr_t
#include <cstdint> #include <cstdint> // for PTRDIFF_MAX
#include <functional> #include <functional> // for divides, multiplies, minus, negate, plus
#include <iterator> #include <initializer_list> // for initializer_list
#include <limits> #include <iterator> // for iterator, random_access_iterator_tag
#include <limits> // for numeric_limits
#include <new> #include <new>
#include <numeric> #include <numeric>
#include <stdexcept> #include <stdexcept>
#include <type_traits> #include <string> // for basic_string
#include <type_traits> // for enable_if_t, remove_cv_t, is_same, is_co...
#include <utility> #include <utility>
#ifdef _MSC_VER #ifdef _MSC_VER
@ -83,12 +85,12 @@ namespace details
} }
template <std::size_t Rank> template <std::size_t Rank>
class index final class multi_span_index final
{ {
static_assert(Rank > 0, "Rank must be greater than 0!"); static_assert(Rank > 0, "Rank must be greater than 0!");
template <std::size_t OtherRank> template <std::size_t OtherRank>
friend class index; friend class multi_span_index;
public: public:
static const std::size_t rank = Rank; static const std::size_t rank = Rank;
@ -97,22 +99,22 @@ public:
using reference = std::add_lvalue_reference_t<value_type>; using reference = std::add_lvalue_reference_t<value_type>;
using const_reference = std::add_lvalue_reference_t<std::add_const_t<value_type>>; using const_reference = std::add_lvalue_reference_t<std::add_const_t<value_type>>;
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); std::copy(values, values + Rank, elems);
} }
template <typename... Ts, typename = std::enable_if_t<(sizeof...(Ts) == Rank) && template <typename... Ts, typename = std::enable_if_t<(sizeof...(Ts) == Rank) &&
details::are_integral<Ts...>::value>> details::are_integral<Ts...>::value>>
constexpr index(Ts... ds) GSL_NOEXCEPT : elems{narrow_cast<value_type>(ds)...} constexpr multi_span_index(Ts... ds) GSL_NOEXCEPT : elems{narrow_cast<value_type>(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 // Preconditions: component_idx < rank
constexpr reference operator[](std::size_t component_idx) constexpr reference operator[](std::size_t component_idx)
@ -128,75 +130,75 @@ public:
return elems[component_idx]; 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); 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<value_type>{}); std::transform(ret, ret + rank, ret, std::negate<value_type>{});
return ret; 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; ret += rhs;
return ret; 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; ret -= rhs;
return ret; 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<value_type>{}); std::transform(elems, elems + rank, rhs.elems, elems, std::plus<value_type>{});
return *this; 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<value_type>{}); std::transform(elems, elems + rank, rhs.elems, elems, std::minus<value_type>{});
return *this; 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; ret *= v;
return ret; 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; ret /= v;
return ret; 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; 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, std::transform(elems, elems + rank, elems,
[v](value_type x) { return std::multiplies<value_type>{}(x, v); }); [v](value_type x) { return std::multiplies<value_type>{}(x, v); });
return *this; 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, std::transform(elems, elems + rank, elems,
[v](value_type x) { return std::divides<value_type>{}(x, v); }); [v](value_type x) { return std::divides<value_type>{}(x, v); });
@ -495,8 +497,8 @@ namespace details
} }
template <std::size_t Rank, bool Enabled = (Rank > 1), template <std::size_t Rank, bool Enabled = (Rank > 1),
typename Ret = std::enable_if_t<Enabled, index<Rank - 1>>> typename Ret = std::enable_if_t<Enabled, multi_span_index<Rank - 1>>>
inline constexpr Ret shift_left(const index<Rank>& other) GSL_NOEXCEPT constexpr Ret shift_left(const multi_span_index<Rank>& other) GSL_NOEXCEPT
{ {
Ret ret{}; Ret ret{};
for (std::size_t i = 0; i < Rank - 1; ++i) { for (std::size_t i = 0; i < Rank - 1; ++i) {
@ -533,7 +535,7 @@ public:
static const std::ptrdiff_t static_size = MyRanges::TotalSize; static const std::ptrdiff_t static_size = MyRanges::TotalSize;
using size_type = std::ptrdiff_t; using size_type = std::ptrdiff_t;
using index_type = index<rank>; using index_type = multi_span_index<rank>;
using const_index_type = std::add_const_t<index_type>; using const_index_type = std::add_const_t<index_type>;
using iterator = bounds_iterator<const_index_type>; using iterator = bounds_iterator<const_index_type>;
using const_iterator = bounds_iterator<const_index_type>; using const_iterator = bounds_iterator<const_index_type>;
@ -629,9 +631,9 @@ public:
return m_ranges.contains(idx) != -1; 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 <std::size_t Dim = 0> template <std::size_t Dim = 0>
@ -696,7 +698,7 @@ public:
using const_reference = std::add_const_t<reference>; using const_reference = std::add_const_t<reference>;
using size_type = value_type; using size_type = value_type;
using difference_type = value_type; using difference_type = value_type;
using index_type = index<rank>; using index_type = multi_span_index<rank>;
using const_index_type = std::add_const_t<index_type>; using const_index_type = std::add_const_t<index_type>;
using iterator = bounds_iterator<const_index_type>; using iterator = bounds_iterator<const_index_type>;
using const_iterator = bounds_iterator<const_index_type>; using const_iterator = bounds_iterator<const_index_type>;
@ -804,17 +806,15 @@ struct is_bounds<strided_bounds<Rank>> : std::integral_constant<bool, true>
}; };
template <typename IndexType> template <typename IndexType>
class bounds_iterator : public std::iterator<std::random_access_iterator_tag, IndexType> class bounds_iterator
{ {
private:
using Base = std::iterator<std::random_access_iterator_tag, IndexType>;
public: public:
static const std::size_t rank = IndexType::rank; static const std::size_t rank = IndexType::rank;
using typename Base::reference; using iterator_category = std::random_access_iterator_tag;
using typename Base::pointer; using value_type = IndexType;
using typename Base::difference_type; using difference_type = std::ptrdiff_t;
using typename Base::value_type; using pointer = value_type*;
using reference = value_type&;
using index_type = value_type; using index_type = value_type;
using index_size_type = typename IndexType::value_type; using index_size_type = typename IndexType::value_type;
template <typename Bounds> template <typename Bounds>
@ -996,7 +996,7 @@ bounds_iterator<IndexType> operator+(typename bounds_iterator<IndexType>::differ
namespace details namespace details
{ {
template <typename Bounds> template <typename Bounds>
inline constexpr std::enable_if_t< constexpr std::enable_if_t<
std::is_same<typename Bounds::mapping_type, generalized_mapping_tag>::value, std::is_same<typename Bounds::mapping_type, generalized_mapping_tag>::value,
typename Bounds::index_type> typename Bounds::index_type>
make_stride(const Bounds& bnd) GSL_NOEXCEPT make_stride(const Bounds& bnd) GSL_NOEXCEPT
@ -1006,7 +1006,7 @@ namespace details
// Make a stride vector from bounds, assuming contiguous memory. // Make a stride vector from bounds, assuming contiguous memory.
template <typename Bounds> template <typename Bounds>
inline constexpr std::enable_if_t< constexpr std::enable_if_t<
std::is_same<typename Bounds::mapping_type, contiguous_mapping_tag>::value, std::is_same<typename Bounds::mapping_type, contiguous_mapping_tag>::value,
typename Bounds::index_type> typename Bounds::index_type>
make_stride(const Bounds& bnd) GSL_NOEXCEPT make_stride(const Bounds& bnd) GSL_NOEXCEPT
@ -1052,17 +1052,17 @@ struct dim_t<dynamic_range>
{ {
static const std::ptrdiff_t value = dynamic_range; static const std::ptrdiff_t value = dynamic_range;
const std::ptrdiff_t dvalue; 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 <std::ptrdiff_t N, class = std::enable_if_t<(N >= 0)>> template <std::ptrdiff_t N, class = std::enable_if_t<(N >= 0)>>
inline constexpr dim_t<N> dim() GSL_NOEXCEPT constexpr dim_t<N> dim() GSL_NOEXCEPT
{ {
return dim_t<N>(); return dim_t<N>();
} }
template <std::ptrdiff_t N = dynamic_range, class = std::enable_if_t<N == dynamic_range>> template <std::ptrdiff_t N = dynamic_range, class = std::enable_if_t<N == dynamic_range>>
inline constexpr dim_t<N> dim(std::ptrdiff_t n) GSL_NOEXCEPT constexpr dim_t<N> dim(std::ptrdiff_t n) GSL_NOEXCEPT
{ {
return dim_t<>(n); return dim_t<>(n);
} }
@ -1070,7 +1070,6 @@ inline constexpr dim_t<N> dim(std::ptrdiff_t n) GSL_NOEXCEPT
template <typename ValueType, std::ptrdiff_t FirstDimension = dynamic_range, template <typename ValueType, std::ptrdiff_t FirstDimension = dynamic_range,
std::ptrdiff_t... RestDimensions> std::ptrdiff_t... RestDimensions>
class multi_span; class multi_span;
template <typename ValueType, std::size_t Rank> template <typename ValueType, std::size_t Rank>
class strided_span; class strided_span;
@ -1479,15 +1478,15 @@ public:
constexpr pointer data() const GSL_NOEXCEPT { return data_; } constexpr pointer data() const GSL_NOEXCEPT { return data_; }
template <typename FirstIndex> template <typename FirstIndex>
constexpr reference operator()(FirstIndex index) constexpr reference operator()(FirstIndex idx)
{ {
return this->operator[](narrow_cast<std::ptrdiff_t>(index)); return this->operator[](narrow_cast<std::ptrdiff_t>(idx));
} }
template <typename FirstIndex, typename... OtherIndices> template <typename FirstIndex, typename... OtherIndices>
constexpr reference operator()(FirstIndex index, OtherIndices... indices) constexpr reference operator()(FirstIndex firstIndex, OtherIndices... indices)
{ {
index_type idx = {narrow_cast<std::ptrdiff_t>(index), index_type idx = {narrow_cast<std::ptrdiff_t>(firstIndex),
narrow_cast<std::ptrdiff_t>(indices)...}; narrow_cast<std::ptrdiff_t>(indices)...};
return this->operator[](idx); return this->operator[](idx);
} }
@ -1600,7 +1599,7 @@ public:
// DimCount and Enabled here are workarounds for a bug in MSVC 2015 // DimCount and Enabled here are workarounds for a bug in MSVC 2015
template <typename SpanType, typename... Dimensions2, std::size_t DimCount = sizeof...(Dimensions2), template <typename SpanType, typename... Dimensions2, std::size_t DimCount = sizeof...(Dimensions2),
bool Enabled = (DimCount > 0), typename = std::enable_if_t<Enabled>> bool Enabled = (DimCount > 0), typename = std::enable_if_t<Enabled>>
inline constexpr auto as_multi_span(SpanType s, Dimensions2... dims) constexpr auto as_multi_span(SpanType s, Dimensions2... dims)
-> multi_span<typename SpanType::value_type, Dimensions2::value...> -> multi_span<typename SpanType::value_type, Dimensions2::value...>
{ {
static_assert(details::is_multi_span<SpanType>::value, static_assert(details::is_multi_span<SpanType>::value,
@ -1638,7 +1637,7 @@ multi_span<byte> as_writeable_bytes(multi_span<U, Dimensions...> s) GSL_NOEXCEPT
// on all implementations. It should be considered an experimental extension // on all implementations. It should be considered an experimental extension
// to the standard GSL interface. // to the standard GSL interface.
template <typename U, std::ptrdiff_t... Dimensions> template <typename U, std::ptrdiff_t... Dimensions>
inline constexpr auto constexpr auto
as_multi_span(multi_span<const byte, Dimensions...> s) GSL_NOEXCEPT -> multi_span< as_multi_span(multi_span<const byte, Dimensions...> s) GSL_NOEXCEPT -> multi_span<
const U, static_cast<std::ptrdiff_t>( const U, static_cast<std::ptrdiff_t>(
multi_span<const byte, Dimensions...>::bounds_type::static_size != dynamic_range multi_span<const byte, Dimensions...>::bounds_type::static_size != dynamic_range
@ -1665,7 +1664,7 @@ as_multi_span(multi_span<const byte, Dimensions...> s) GSL_NOEXCEPT -> multi_spa
// on all implementations. It should be considered an experimental extension // on all implementations. It should be considered an experimental extension
// to the standard GSL interface. // to the standard GSL interface.
template <typename U, std::ptrdiff_t... Dimensions> template <typename U, std::ptrdiff_t... Dimensions>
inline constexpr auto as_multi_span(multi_span<byte, Dimensions...> s) GSL_NOEXCEPT constexpr auto as_multi_span(multi_span<byte, Dimensions...> s) GSL_NOEXCEPT
-> multi_span<U, narrow_cast<std::ptrdiff_t>( -> multi_span<U, narrow_cast<std::ptrdiff_t>(
multi_span<byte, Dimensions...>::bounds_type::static_size != dynamic_range multi_span<byte, Dimensions...>::bounds_type::static_size != dynamic_range
? static_cast<std::size_t>( ? static_cast<std::size_t>(
@ -1686,7 +1685,7 @@ inline constexpr auto as_multi_span(multi_span<byte, Dimensions...> s) GSL_NOEXC
} }
template <typename T, std::ptrdiff_t... Dimensions> template <typename T, std::ptrdiff_t... Dimensions>
inline constexpr auto as_multi_span(T* const& ptr, dim_t<Dimensions>... args) constexpr auto as_multi_span(T* const& ptr, dim_t<Dimensions>... args)
-> multi_span<std::remove_all_extents_t<T>, Dimensions...> -> multi_span<std::remove_all_extents_t<T>, Dimensions...>
{ {
return {reinterpret_cast<std::remove_all_extents_t<T>*>(ptr), return {reinterpret_cast<std::remove_all_extents_t<T>*>(ptr),
@ -1695,41 +1694,41 @@ inline constexpr auto as_multi_span(T* const& ptr, dim_t<Dimensions>... args)
} }
template <typename T> template <typename T>
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<T, dynamic_range>::type typename details::SpanArrayTraits<T, dynamic_range>::type
{ {
return {reinterpret_cast<std::remove_all_extents_t<T>*>(arr), len}; return {reinterpret_cast<std::remove_all_extents_t<T>*>(arr), len};
} }
template <typename T, std::size_t N> template <typename T, std::size_t N>
inline constexpr auto as_multi_span(T (&arr)[N]) -> typename details::SpanArrayTraits<T, N>::type constexpr auto as_multi_span(T (&arr)[N]) -> typename details::SpanArrayTraits<T, N>::type
{ {
return {arr}; return {arr};
} }
template <typename T, std::size_t N> template <typename T, std::size_t N>
inline constexpr multi_span<const T, N> as_multi_span(const std::array<T, N>& arr) constexpr multi_span<const T, N> as_multi_span(const std::array<T, N>& arr)
{ {
return {arr}; return {arr};
} }
template <typename T, std::size_t N> template <typename T, std::size_t N>
inline constexpr multi_span<const T, N> as_multi_span(const std::array<T, N>&&) = delete; constexpr multi_span<const T, N> as_multi_span(const std::array<T, N>&&) = delete;
template <typename T, std::size_t N> template <typename T, std::size_t N>
inline constexpr multi_span<T, N> as_multi_span(std::array<T, N>& arr) constexpr multi_span<T, N> as_multi_span(std::array<T, N>& arr)
{ {
return {arr}; return {arr};
} }
template <typename T> template <typename T>
inline constexpr multi_span<T, dynamic_range> as_multi_span(T* begin, T* end) constexpr multi_span<T, dynamic_range> as_multi_span(T* begin, T* end)
{ {
return {begin, end}; return {begin, end};
} }
template <typename Cont> template <typename Cont>
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<std::decay_t<Cont>>::value, !details::is_multi_span<std::decay_t<Cont>>::value,
multi_span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>> multi_span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>>
{ {
@ -1738,13 +1737,13 @@ inline constexpr auto as_multi_span(Cont& arr) -> std::enable_if_t<
} }
template <typename Cont> template <typename Cont>
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<std::decay_t<Cont>>::value, !details::is_multi_span<std::decay_t<Cont>>::value,
multi_span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>> = delete; multi_span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>> = delete;
// from basic_string which doesn't have nonconst .data() member like other contiguous containers // from basic_string which doesn't have nonconst .data() member like other contiguous containers
template <typename CharT, typename Traits, typename Allocator> template <typename CharT, typename Traits, typename Allocator>
inline constexpr auto as_multi_span(std::basic_string<CharT, Traits, Allocator>& str) constexpr auto as_multi_span(std::basic_string<CharT, Traits, Allocator>& str)
-> multi_span<CharT, dynamic_range> -> multi_span<CharT, dynamic_range>
{ {
Expects(str.size() < PTRDIFF_MAX); Expects(str.size() < PTRDIFF_MAX);
@ -1996,14 +1995,13 @@ private:
template <class Span> template <class Span>
class contiguous_span_iterator class contiguous_span_iterator
: public std::iterator<std::random_access_iterator_tag, typename Span::value_type>
{ {
using Base = std::iterator<std::random_access_iterator_tag, typename Span::value_type>;
public: public:
using typename Base::reference; using iterator_category = std::random_access_iterator_tag;
using typename Base::pointer; using value_type = typename Span::value_type;
using typename Base::difference_type; using difference_type = std::ptrdiff_t;
using pointer = value_type*;
using reference = value_type&;
private: private:
template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions> template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions>
@ -2116,15 +2114,13 @@ contiguous_span_iterator<Span> operator+(typename contiguous_span_iterator<Span>
template <typename Span> template <typename Span>
class general_span_iterator class general_span_iterator
: public std::iterator<std::random_access_iterator_tag, typename Span::value_type>
{ {
using Base = std::iterator<std::random_access_iterator_tag, typename Span::value_type>;
public: public:
using typename Base::reference; using iterator_category = std::random_access_iterator_tag;
using typename Base::pointer; using value_type = typename Span::value_type;
using typename Base::difference_type; using difference_type = std::ptrdiff_t;
using typename Base::value_type; using pointer = value_type*;
using reference = value_type&;
private: private:
template <typename ValueType, std::size_t Rank> template <typename ValueType, std::size_t Rank>

11
Telegram/ThirdParty/GSL/include/gsl/pointers vendored
View File

@ -17,11 +17,13 @@
#ifndef GSL_POINTERS_H #ifndef GSL_POINTERS_H
#define GSL_POINTERS_H #define GSL_POINTERS_H
#include <gsl/gsl_assert> #include <gsl/gsl_assert> // for Ensures, Expects
#include <iosfwd> #include <algorithm> // for forward
#include <memory> #include <iosfwd> // for ptrdiff_t, nullptr_t, ostream, size_t
#include <type_traits> #include <memory> // for shared_ptr, unique_ptr
#include <system_error> // for hash
#include <type_traits> // for enable_if_t, is_convertible, is_assignable
#if defined(_MSC_VER) && _MSC_VER < 1910 #if defined(_MSC_VER) && _MSC_VER < 1910
#pragma push_macro("constexpr") #pragma push_macro("constexpr")
@ -80,6 +82,7 @@ public:
{ {
} }
not_null(not_null&& other) = default;
not_null(const not_null& other) = default; not_null(const not_null& other) = default;
not_null& operator=(const not_null& other) = default; not_null& operator=(const not_null& other) = default;

222
Telegram/ThirdParty/GSL/include/gsl/span vendored
View File

@ -17,16 +17,17 @@
#ifndef GSL_SPAN_H #ifndef GSL_SPAN_H
#define GSL_SPAN_H #define GSL_SPAN_H
#include <gsl/gsl_assert> #include <gsl/gsl_assert> // for Expects
#include <gsl/gsl_byte> #include <gsl/gsl_byte> // for byte
#include <gsl/gsl_util> #include <gsl/gsl_util> // for narrow_cast, narrow
#include <array> #include <algorithm> // for lexicographical_compare
#include <iterator> #include <array> // for array
#include <cstddef> // for ptrdiff_t, size_t, nullptr_t
#include <iterator> // for reverse_iterator, distance, random_access_...
#include <limits> #include <limits>
#include <memory>
#include <stdexcept> #include <stdexcept>
#include <type_traits> #include <type_traits> // for enable_if_t, declval, is_convertible, inte...
#include <utility> #include <utility>
#ifdef _MSC_VER #ifdef _MSC_VER
@ -44,15 +45,20 @@
#if _MSC_VER < 1910 #if _MSC_VER < 1910
#pragma push_macro("constexpr") #pragma push_macro("constexpr")
#define constexpr /*constexpr*/ #define constexpr /*constexpr*/
#define GSL_USE_STATIC_CONSTEXPR_WORKAROUND
#endif // _MSC_VER < 1910 #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 #endif // _MSC_VER
#ifdef GSL_THROW_ON_CONTRACT_VIOLATION
#define GSL_NOEXCEPT /*noexcept*/
#else
#define GSL_NOEXCEPT noexcept #define GSL_NOEXCEPT noexcept
#endif // GSL_THROW_ON_CONTRACT_VIOLATION
namespace gsl namespace gsl
{ {
@ -115,6 +121,12 @@ namespace details
using element_type_ = typename Span::element_type; using element_type_ = typename Span::element_type;
public: 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 iterator_category = std::random_access_iterator_tag;
using value_type = std::remove_cv_t<element_type_>; using value_type = std::remove_cv_t<element_type_>;
using difference_type = typename Span::index_type; using difference_type = typename Span::index_type;
@ -124,11 +136,9 @@ namespace details
span_iterator() = default; span_iterator() = default;
constexpr span_iterator(const Span* span, typename Span::index_type index) GSL_NOEXCEPT constexpr span_iterator(const Span* span, typename Span::index_type idx) GSL_NOEXCEPT
: span_(span), index_(index) : span_(span), index_(idx)
{ {}
Expects(span == nullptr || (0 <= index_ && index <= span_->length()));
}
friend span_iterator<Span, true>; friend span_iterator<Span, true>;
template<bool B, std::enable_if_t<!B && IsConst>* = nullptr> template<bool B, std::enable_if_t<!B && IsConst>* = 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_); 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_; 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_; ++index_;
return *this; return *this;
} }
constexpr span_iterator operator++(int) GSL_NOEXCEPT constexpr span_iterator operator++(int)
{ {
auto ret = *this; auto ret = *this;
++(*this); ++(*this);
return ret; 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_; --index_;
return *this; return *this;
} }
constexpr span_iterator operator--(int) GSL_NOEXCEPT constexpr span_iterator operator--(int)
{ {
auto ret = *this; auto ret = *this;
--(*this); --(*this);
return ret; return ret;
} }
constexpr span_iterator operator+(difference_type n) const GSL_NOEXCEPT constexpr span_iterator operator+(difference_type n) const
{ {
auto ret = *this; auto ret = *this;
return ret += n; 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; index_ += n;
return *this; return *this;
} }
constexpr span_iterator operator-(difference_type n) const GSL_NOEXCEPT constexpr span_iterator operator-(difference_type n) const
{ {
auto ret = *this; auto ret = *this;
return ret -= n; 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_); Expects(span_ == rhs.span_);
return index_ - rhs.index_; return index_ - rhs.index_;
} }
constexpr reference operator[](difference_type n) const GSL_NOEXCEPT constexpr reference operator[](difference_type n) const
{ {
return *(*this + n); return *(*this + n);
} }
constexpr friend bool operator==(const span_iterator& lhs, constexpr friend bool operator==(span_iterator lhs,
const span_iterator& rhs) GSL_NOEXCEPT span_iterator rhs) GSL_NOEXCEPT
{ {
return lhs.span_ == rhs.span_ && lhs.index_ == rhs.index_; return lhs.span_ == rhs.span_ && lhs.index_ == rhs.index_;
} }
constexpr friend bool operator!=(const span_iterator& lhs, constexpr friend bool operator!=(span_iterator lhs,
const span_iterator& rhs) GSL_NOEXCEPT span_iterator rhs) GSL_NOEXCEPT
{ {
return !(lhs == rhs); return !(lhs == rhs);
} }
constexpr friend bool operator<(const span_iterator& lhs, constexpr friend bool operator<(span_iterator lhs,
const span_iterator& rhs) GSL_NOEXCEPT span_iterator rhs) GSL_NOEXCEPT
{ {
Expects(lhs.span_ == rhs.span_);
return lhs.index_ < rhs.index_; return lhs.index_ < rhs.index_;
} }
constexpr friend bool operator<=(const span_iterator& lhs, constexpr friend bool operator<=(span_iterator lhs,
const span_iterator& rhs) GSL_NOEXCEPT span_iterator rhs) GSL_NOEXCEPT
{ {
return !(rhs < lhs); return !(rhs < lhs);
} }
constexpr friend bool operator>(const span_iterator& lhs, constexpr friend bool operator>(span_iterator lhs,
const span_iterator& rhs) GSL_NOEXCEPT span_iterator rhs) GSL_NOEXCEPT
{ {
return rhs < lhs; return rhs < lhs;
} }
constexpr friend bool operator>=(const span_iterator& lhs, constexpr friend bool operator>=(span_iterator lhs,
const span_iterator& rhs) GSL_NOEXCEPT span_iterator rhs) GSL_NOEXCEPT
{ {
return !(rhs > lhs); return !(rhs > lhs);
} }
@ -252,17 +261,17 @@ namespace details
}; };
template <class Span, bool IsConst> template <class Span, bool IsConst>
inline constexpr span_iterator<Span, IsConst> constexpr span_iterator<Span, IsConst>
operator+(typename span_iterator<Span, IsConst>::difference_type n, operator+(typename span_iterator<Span, IsConst>::difference_type n,
const span_iterator<Span, IsConst>& rhs) GSL_NOEXCEPT span_iterator<Span, IsConst> rhs)
{ {
return rhs + n; return rhs + n;
} }
template <class Span, bool IsConst> template <class Span, bool IsConst>
inline constexpr span_iterator<Span, IsConst> constexpr span_iterator<Span, IsConst>
operator-(typename span_iterator<Span, IsConst>::difference_type n, operator-(typename span_iterator<Span, IsConst>::difference_type n,
const span_iterator<Span, IsConst>& rhs) GSL_NOEXCEPT span_iterator<Span, IsConst> rhs)
{ {
return rhs - n; return rhs - n;
} }
@ -308,6 +317,12 @@ namespace details
private: private:
index_type size_; index_type size_;
}; };
template <class ElementType, std::ptrdiff_t Extent, std::ptrdiff_t Offset, std::ptrdiff_t Count>
struct calculate_subspan_type
{
using type = span<ElementType, Count != dynamic_extent ? Count : (Extent != dynamic_extent ? Extent - Offset : Extent)>;
};
} // namespace details } // namespace details
// [span], class template span // [span], class template span
@ -329,7 +344,11 @@ public:
using size_type = index_type; 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 // [span.cons], span constructors, copy, assignment, and destructor
template <bool Dependent = false, template <bool Dependent = false,
@ -340,8 +359,6 @@ public:
{ {
} }
constexpr span(std::nullptr_t) GSL_NOEXCEPT : span() {}
constexpr span(pointer ptr, index_type count) : storage_(ptr, count) {} constexpr span(pointer ptr, index_type count) : storage_(ptr, count) {}
constexpr span(pointer firstElem, pointer lastElem) constexpr span(pointer firstElem, pointer lastElem)
@ -367,19 +384,6 @@ public:
{ {
} }
template <class ArrayElementType = std::add_pointer<element_type>>
constexpr span(const std::unique_ptr<ArrayElementType>& ptr, index_type count)
: storage_(ptr.get(), count)
{
}
constexpr span(const std::unique_ptr<ElementType>& ptr) : storage_(ptr.get(), ptr.get() ? 1 : 0)
{
}
constexpr span(const std::shared_ptr<ElementType>& ptr) : storage_(ptr.get(), ptr.get() ? 1 : 0)
{
}
// NB: the SFINAE here uses .data() as a incomplete/imperfect proxy for the requirement // NB: the SFINAE here uses .data() as a incomplete/imperfect proxy for the requirement
// on Container to be a contiguous sequence container. // on Container to be a contiguous sequence container.
template <class Container, template <class Container,
@ -403,7 +407,6 @@ public:
} }
constexpr span(const span& other) GSL_NOEXCEPT = default; constexpr span(const span& other) GSL_NOEXCEPT = default;
constexpr span(span&& other) GSL_NOEXCEPT = default;
template < template <
class OtherElementType, std::ptrdiff_t OtherExtent, class OtherElementType, std::ptrdiff_t OtherExtent,
@ -415,21 +418,9 @@ public:
{ {
} }
template <
class OtherElementType, std::ptrdiff_t OtherExtent,
class = std::enable_if_t<
details::is_allowed_extent_conversion<OtherExtent, Extent>::value &&
details::is_allowed_element_type_conversion<OtherElementType, element_type>::value>>
constexpr span(span<OtherElementType, OtherExtent>&& other)
: storage_(other.data(), details::extent_type<OtherExtent>(other.size()))
{
}
~span() GSL_NOEXCEPT = default; ~span() GSL_NOEXCEPT = default;
constexpr span& operator=(const span& other) GSL_NOEXCEPT = default; constexpr span& operator=(const span& other) GSL_NOEXCEPT = default;
constexpr span& operator=(span&& other) GSL_NOEXCEPT = default;
// [span.sub], span subviews // [span.sub], span subviews
template <std::ptrdiff_t Count> template <std::ptrdiff_t Count>
constexpr span<element_type, Count> first() const constexpr span<element_type, Count> first() const
@ -446,7 +437,7 @@ public:
} }
template <std::ptrdiff_t Offset, std::ptrdiff_t Count = dynamic_extent> template <std::ptrdiff_t Offset, std::ptrdiff_t Count = dynamic_extent>
constexpr span<element_type, Count> subspan() const constexpr auto subspan() const -> typename details::calculate_subspan_type<ElementType, Extent, Offset, Count>::type
{ {
Expects((Offset >= 0 && size() - Offset >= 0) && Expects((Offset >= 0 && size() - Offset >= 0) &&
(Count == dynamic_extent || (Count >= 0 && Offset + Count <= size()))); (Count == dynamic_extent || (Count >= 0 && Offset + Count <= size())));
@ -473,9 +464,7 @@ public:
// [span.obs], span observers // [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 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 constexpr index_type size_bytes() const GSL_NOEXCEPT
{ {
return size() * narrow_cast<index_type>(sizeof(element_type)); return size() * narrow_cast<index_type>(sizeof(element_type));
@ -494,17 +483,17 @@ public:
constexpr pointer data() const GSL_NOEXCEPT { return storage_.data(); } constexpr pointer data() const GSL_NOEXCEPT { return storage_.data(); }
// [span.iter], span iterator support // [span.iter], span iterator support
iterator begin() const GSL_NOEXCEPT { return {this, 0}; } constexpr iterator begin() const GSL_NOEXCEPT { return {this, 0}; }
iterator end() const GSL_NOEXCEPT { return {this, length()}; } constexpr iterator end() const GSL_NOEXCEPT { return {this, size()}; }
const_iterator cbegin() const GSL_NOEXCEPT { return {this, 0}; } constexpr const_iterator cbegin() const GSL_NOEXCEPT { return {this, 0}; }
const_iterator cend() const GSL_NOEXCEPT { return {this, length()}; } constexpr const_iterator cend() const GSL_NOEXCEPT { return {this, size()}; }
reverse_iterator rbegin() const GSL_NOEXCEPT { return reverse_iterator{end()}; } constexpr reverse_iterator rbegin() const GSL_NOEXCEPT { return reverse_iterator{end()}; }
reverse_iterator rend() const GSL_NOEXCEPT { return reverse_iterator{begin()}; } constexpr reverse_iterator rend() const GSL_NOEXCEPT { return reverse_iterator{begin()}; }
const_reverse_iterator crbegin() const GSL_NOEXCEPT { return const_reverse_iterator{cend()}; } constexpr 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 crend() const GSL_NOEXCEPT { return const_reverse_iterator{cbegin()}; }
private: private:
// this implementation detail class lets us take advantage of the // this implementation detail class lets us take advantage of the
@ -540,7 +529,7 @@ private:
template <std::ptrdiff_t CallerExtent> template <std::ptrdiff_t CallerExtent>
span<element_type, dynamic_extent> make_subspan(index_type offset, span<element_type, dynamic_extent> make_subspan(index_type offset,
index_type count, index_type count,
subspan_selector<CallerExtent>) const GSL_NOEXCEPT subspan_selector<CallerExtent>) const
{ {
span<element_type, dynamic_extent> tmp(*this); span<element_type, dynamic_extent> tmp(*this);
return tmp.subspan(offset, count); return tmp.subspan(offset, count);
@ -548,7 +537,7 @@ private:
span<element_type, dynamic_extent> make_subspan(index_type offset, span<element_type, dynamic_extent> make_subspan(index_type offset,
index_type count, index_type count,
subspan_selector<dynamic_extent>) const GSL_NOEXCEPT subspan_selector<dynamic_extent>) const
{ {
Expects(offset >= 0 && size() - offset >= 0); Expects(offset >= 0 && size() - offset >= 0);
if (count == dynamic_extent) if (count == dynamic_extent)
@ -561,46 +550,51 @@ private:
} }
}; };
#if defined(GSL_USE_STATIC_CONSTEXPR_WORKAROUND)
template <class ElementType, std::ptrdiff_t Extent>
constexpr const typename span<ElementType, Extent>::index_type span<ElementType, Extent>::extent;
#endif
// [span.comparison], span comparison operators // [span.comparison], span comparison operators
template <class ElementType, std::ptrdiff_t FirstExtent, std::ptrdiff_t SecondExtent> template <class ElementType, std::ptrdiff_t FirstExtent, std::ptrdiff_t SecondExtent>
inline constexpr bool operator==(const span<ElementType, FirstExtent>& l, constexpr bool operator==(span<ElementType, FirstExtent> l,
const span<ElementType, SecondExtent>& r) span<ElementType, SecondExtent> r)
{ {
return std::equal(l.begin(), l.end(), r.begin(), r.end()); return std::equal(l.begin(), l.end(), r.begin(), r.end());
} }
template <class ElementType, std::ptrdiff_t Extent> template <class ElementType, std::ptrdiff_t Extent>
inline constexpr bool operator!=(const span<ElementType, Extent>& l, constexpr bool operator!=(span<ElementType, Extent> l,
const span<ElementType, Extent>& r) span<ElementType, Extent> r)
{ {
return !(l == r); return !(l == r);
} }
template <class ElementType, std::ptrdiff_t Extent> template <class ElementType, std::ptrdiff_t Extent>
inline constexpr bool operator<(const span<ElementType, Extent>& l, constexpr bool operator<(span<ElementType, Extent> l,
const span<ElementType, Extent>& r) span<ElementType, Extent> r)
{ {
return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end()); return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end());
} }
template <class ElementType, std::ptrdiff_t Extent> template <class ElementType, std::ptrdiff_t Extent>
inline constexpr bool operator<=(const span<ElementType, Extent>& l, constexpr bool operator<=(span<ElementType, Extent> l,
const span<ElementType, Extent>& r) span<ElementType, Extent> r)
{ {
return !(l > r); return !(l > r);
} }
template <class ElementType, std::ptrdiff_t Extent> template <class ElementType, std::ptrdiff_t Extent>
inline constexpr bool operator>(const span<ElementType, Extent>& l, constexpr bool operator>(span<ElementType, Extent> l,
const span<ElementType, Extent>& r) span<ElementType, Extent> r)
{ {
return r < l; return r < l;
} }
template <class ElementType, std::ptrdiff_t Extent> template <class ElementType, std::ptrdiff_t Extent>
inline constexpr bool operator>=(const span<ElementType, Extent>& l, constexpr bool operator>=(span<ElementType, Extent> l,
const span<ElementType, Extent>& r) span<ElementType, Extent> r)
{ {
return !(l < r); return !(l < r);
} }
@ -648,53 +642,53 @@ as_writeable_bytes(span<ElementType, Extent> s) GSL_NOEXCEPT
// make_span() - Utility functions for creating spans // make_span() - Utility functions for creating spans
// //
template <class ElementType> template <class ElementType>
span<ElementType> make_span(ElementType* ptr, typename span<ElementType>::index_type count) constexpr span<ElementType> make_span(ElementType* ptr, typename span<ElementType>::index_type count)
{ {
return span<ElementType>(ptr, count); return span<ElementType>(ptr, count);
} }
template <class ElementType> template <class ElementType>
span<ElementType> make_span(ElementType* firstElem, ElementType* lastElem) constexpr span<ElementType> make_span(ElementType* firstElem, ElementType* lastElem)
{ {
return span<ElementType>(firstElem, lastElem); return span<ElementType>(firstElem, lastElem);
} }
template <class ElementType, std::size_t N> template <class ElementType, std::size_t N>
span<ElementType, N> make_span(ElementType (&arr)[N]) constexpr span<ElementType, N> make_span(ElementType (&arr)[N]) GSL_NOEXCEPT
{ {
return span<ElementType, N>(arr); return span<ElementType, N>(arr);
} }
template <class Container> template <class Container>
span<typename Container::value_type> make_span(Container& cont) constexpr span<typename Container::value_type> make_span(Container& cont)
{ {
return span<typename Container::value_type>(cont); return span<typename Container::value_type>(cont);
} }
template <class Container> template <class Container>
span<const typename Container::value_type> make_span(const Container& cont) constexpr span<const typename Container::value_type> make_span(const Container& cont)
{ {
return span<const typename Container::value_type>(cont); return span<const typename Container::value_type>(cont);
} }
template <class Ptr> template <class Ptr>
span<typename Ptr::element_type> make_span(Ptr& cont, std::ptrdiff_t count) constexpr span<typename Ptr::element_type> make_span(Ptr& cont, std::ptrdiff_t count)
{ {
return span<typename Ptr::element_type>(cont, count); return span<typename Ptr::element_type>(cont, count);
} }
template <class Ptr> template <class Ptr>
span<typename Ptr::element_type> make_span(Ptr& cont) constexpr span<typename Ptr::element_type> make_span(Ptr& cont)
{ {
return span<typename Ptr::element_type>(cont); return span<typename Ptr::element_type>(cont);
} }
// Specialization of gsl::at for span // Specialization of gsl::at for span
template <class ElementType, std::ptrdiff_t Extent> template <class ElementType, std::ptrdiff_t Extent>
inline constexpr ElementType& at(const span<ElementType, Extent>& s, std::ptrdiff_t index) constexpr ElementType& at(span<ElementType, Extent> s, index i)
{ {
// No bounds checking here because it is done in span::operator[] called below // No bounds checking here because it is done in span::operator[] called below
return s[index]; return s[i];
} }
} // namespace gsl } // namespace gsl

29
Telegram/ThirdParty/GSL/include/gsl/string_span vendored
View File

@ -17,13 +17,17 @@
#ifndef GSL_STRING_SPAN_H #ifndef GSL_STRING_SPAN_H
#define GSL_STRING_SPAN_H #define GSL_STRING_SPAN_H
#include <gsl/gsl_assert> #include <gsl/gsl_assert> // for Ensures, Expects
#include <gsl/gsl_util> #include <gsl/gsl_util> // for narrow_cast
#include <gsl/span> #include <gsl/span> // for operator!=, operator==, dynamic_extent
#include <cstdint> #include <algorithm> // for equal, lexicographical_compare
#include <array> // for array
#include <cstddef> // for ptrdiff_t, size_t, nullptr_t
#include <cstdint> // for PTRDIFF_MAX
#include <cstring> #include <cstring>
#include <string> #include <string> // for basic_string, allocator, char_traits
#include <type_traits> // for declval, is_convertible, enable_if_t, add_...
#ifdef _MSC_VER #ifdef _MSC_VER
#pragma warning(push) #pragma warning(push)
@ -94,7 +98,7 @@ namespace details
{ {
if (str == nullptr || n <= 0) return 0; if (str == nullptr || n <= 0) return 0;
span<const CharT> str_span{str, n}; const span<const CharT> str_span{str, n};
std::ptrdiff_t len = 0; std::ptrdiff_t len = 0;
while (len < n && str_span[len]) len++; while (len < n && str_span[len]) len++;
@ -126,7 +130,7 @@ span<T, dynamic_extent> ensure_sentinel(T* seq, std::ptrdiff_t max = PTRDIFF_MAX
// the limit of size_type. // the limit of size_type.
// //
template <typename CharT> template <typename CharT>
inline span<CharT, dynamic_extent> ensure_z(CharT* const& sz, std::ptrdiff_t max = PTRDIFF_MAX) span<CharT, dynamic_extent> ensure_z(CharT* const& sz, std::ptrdiff_t max = PTRDIFF_MAX)
{ {
return ensure_sentinel<CharT, CharT(0)>(sz, max); return ensure_sentinel<CharT, CharT(0)>(sz, max);
} }
@ -141,7 +145,7 @@ template <class Cont>
span<typename std::remove_pointer<typename Cont::pointer>::type, dynamic_extent> span<typename std::remove_pointer<typename Cont::pointer>::type, dynamic_extent>
ensure_z(Cont& cont) ensure_z(Cont& cont)
{ {
return ensure_z(cont.data(), static_cast<std::ptrdiff_t>(cont.length())); return ensure_z(cont.data(), static_cast<std::ptrdiff_t>(cont.size()));
} }
template <typename CharT, std::ptrdiff_t> template <typename CharT, std::ptrdiff_t>
@ -190,18 +194,9 @@ public:
// copy // copy
constexpr basic_string_span(const basic_string_span& other) GSL_NOEXCEPT = default; 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 // assign
constexpr basic_string_span& operator=(const basic_string_span& other) GSL_NOEXCEPT = default; 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 ptr, index_type length) : span_(ptr, length) {}
constexpr basic_string_span(pointer firstElem, pointer lastElem) : span_(firstElem, lastElem) {} constexpr basic_string_span(pointer firstElem, pointer lastElem) : span_(firstElem, lastElem) {}

12
Telegram/ThirdParty/GSL/tests/algorithm_tests.cpp vendored
View File

@ -14,11 +14,17 @@
// //
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#include <catch/catch.hpp> #include <catch/catch.hpp> // for AssertionHandler, StringRef, CHECK, CHE...
#include <gsl/gsl_algorithm> #include <gsl/gsl_algorithm> // for copy
#include <gsl/span> // for span
#include <array> #include <array> // for array
#include <cstddef> // for size_t
namespace gsl {
struct fail_fast;
} // namespace gsl
using namespace std; using namespace std;
using namespace gsl; using namespace gsl;

4
Telegram/ThirdParty/GSL/tests/assertion_tests.cpp vendored
View File

@ -14,9 +14,9 @@
// //
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#include <catch/catch.hpp> #include <catch/catch.hpp> // for AssertionHandler, StringRef, CHECK, CHECK...
#include <gsl/gsl> #include <gsl/gsl_assert> // for fail_fast (ptr only), Ensures, Expects
using namespace gsl; using namespace gsl;

14
Telegram/ThirdParty/GSL/tests/at_tests.cpp vendored
View File

@ -14,12 +14,18 @@
// //
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#include <catch/catch.hpp> #include <catch/catch.hpp> // for AssertionHandler, StringRef, CHECK_THROW...
#include <gsl/gsl> #include <gsl/gsl_util> // for at
#include <initializer_list> #include <array> // for array
#include <vector> #include <cstddef> // for size_t
#include <initializer_list> // for initializer_list
#include <vector> // for vector
namespace gsl {
struct fail_fast;
} // namespace gsl
using gsl::fail_fast; using gsl::fail_fast;

10
Telegram/ThirdParty/GSL/tests/bounds_tests.cpp vendored
View File

@ -14,11 +14,15 @@
// //
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#include <catch/catch.hpp> #include <catch/catch.hpp> // for AssertionHandler, StringRef, TEST_CASE
#include <gsl/multi_span> #include <gsl/multi_span> // for static_bounds, static_bounds_dynamic_range_t
#include <vector> #include <cstddef> // for ptrdiff_t, size_t
namespace gsl {
struct fail_fast;
} // namespace gsl
using namespace std; using namespace std;
using namespace gsl; using namespace gsl;

11
Telegram/ThirdParty/GSL/tests/byte_tests.cpp vendored
View File

@ -14,16 +14,9 @@
// //
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#include <catch/catch.hpp> #include <catch/catch.hpp> // for AssertionHandler, StringRef, CHECK, TEST_...
#include <gsl/gsl_byte> #include <gsl/gsl_byte> // for to_byte, to_integer, byte, operator&, ope...
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <string>
#include <vector>
using namespace std; using namespace std;
using namespace gsl; using namespace gsl;

84
Telegram/ThirdParty/GSL/tests/multi_span_tests.cpp vendored
View File

@ -14,16 +14,24 @@
// //
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#include <catch/catch.hpp> #include <catch/catch.hpp> // for AssertionHandler, StringRef, CHECK, CHECK...
#include <gsl/multi_span> #include <gsl/gsl_byte> // for byte
#include <gsl/gsl_util> // for narrow_cast
#include <gsl/multi_span> // for multi_span, contiguous_span_iterator, dim
#include <iostream> #include <algorithm> // for fill, for_each
#include <list> #include <array> // for array
#include <map> #include <iostream> // for ptrdiff_t, size_t
#include <memory> #include <iterator> // for reverse_iterator, begin, end, operator!=
#include <string> #include <numeric> // for iota
#include <vector> #include <stddef.h> // for ptrdiff_t
#include <string> // for string
#include <vector> // for vector
namespace gsl {
struct fail_fast;
} // namespace gsl
using namespace std; using namespace std;
using namespace gsl; using namespace gsl;
@ -1235,7 +1243,7 @@ TEST_CASE("empty_spans")
{ {
multi_span<int, 0> empty_av(nullptr); multi_span<int, 0> 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[0], fail_fast);
CHECK_THROWS_AS(empty_av.begin()[0], fail_fast); CHECK_THROWS_AS(empty_av.begin()[0], fail_fast);
CHECK_THROWS_AS(empty_av.cbegin()[0], fail_fast); CHECK_THROWS_AS(empty_av.cbegin()[0], fail_fast);
@ -1247,7 +1255,7 @@ TEST_CASE("empty_spans")
{ {
multi_span<int> empty_av = {}; multi_span<int> 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[0], fail_fast);
CHECK_THROWS_AS(empty_av.begin()[0], fail_fast); CHECK_THROWS_AS(empty_av.begin()[0], fail_fast);
CHECK_THROWS_AS(empty_av.cbegin()[0], fail_fast); CHECK_THROWS_AS(empty_av.cbegin()[0], fail_fast);
@ -1269,13 +1277,13 @@ TEST_CASE("index_constructor")
multi_span<int, dynamic_range> av(arr, 8); multi_span<int, dynamic_range> av(arr, 8);
ptrdiff_t a[1] = {0}; ptrdiff_t a[1] = {0};
index<1> i = a; multi_span_index<1> i = a;
CHECK(av[i] == 4); CHECK(av[i] == 4);
auto av2 = as_multi_span(av, dim<4>(), dim(2)); auto av2 = as_multi_span(av, dim<4>(), dim(2));
ptrdiff_t a2[2] = {0, 1}; ptrdiff_t a2[2] = {0, 1};
index<2> i2 = a2; multi_span_index<2> i2 = a2;
CHECK(av2[i2] == 0); CHECK(av2[i2] == 0);
CHECK(av2[0][i] == 4); CHECK(av2[0][i] == 4);
@ -1287,70 +1295,70 @@ TEST_CASE("index_constructors")
{ {
{ {
// components of the same type // components of the same type
index<3> i1(0, 1, 2); multi_span_index<3> i1(0, 1, 2);
CHECK(i1[0] == 0); CHECK(i1[0] == 0);
// components of different types // components of different types
std::size_t c0 = 0; std::size_t c0 = 0;
std::size_t c1 = 1; std::size_t c1 = 1;
index<3> i2(c0, c1, 2); multi_span_index<3> i2(c0, c1, 2);
CHECK(i2[0] == 0); CHECK(i2[0] == 0);
// from array // from array
index<3> i3 = {0, 1, 2}; multi_span_index<3> i3 = {0, 1, 2};
CHECK(i3[0] == 0); CHECK(i3[0] == 0);
// from other index of the same size type // from other index of the same size type
index<3> i4 = i3; multi_span_index<3> i4 = i3;
CHECK(i4[0] == 0); CHECK(i4[0] == 0);
// default // default
index<3> i7; multi_span_index<3> i7;
CHECK(i7[0] == 0); CHECK(i7[0] == 0);
// default // default
index<3> i9 = {}; multi_span_index<3> i9 = {};
CHECK(i9[0] == 0); CHECK(i9[0] == 0);
} }
{ {
// components of the same type // components of the same type
index<1> i1(0); multi_span_index<1> i1(0);
CHECK(i1[0] == 0); CHECK(i1[0] == 0);
// components of different types // components of different types
std::size_t c0 = 0; std::size_t c0 = 0;
index<1> i2(c0); multi_span_index<1> i2(c0);
CHECK(i2[0] == 0); CHECK(i2[0] == 0);
// from array // from array
index<1> i3 = {0}; multi_span_index<1> i3 = {0};
CHECK(i3[0] == 0); CHECK(i3[0] == 0);
// from int // from int
index<1> i4 = 0; multi_span_index<1> i4 = 0;
CHECK(i4[0] == 0); CHECK(i4[0] == 0);
// from other index of the same size type // from other index of the same size type
index<1> i5 = i3; multi_span_index<1> i5 = i3;
CHECK(i5[0] == 0); CHECK(i5[0] == 0);
// default // default
index<1> i8; multi_span_index<1> i8;
CHECK(i8[0] == 0); CHECK(i8[0] == 0);
// default // default
index<1> i9 = {}; multi_span_index<1> i9 = {};
CHECK(i9[0] == 0); CHECK(i9[0] == 0);
} }
#ifdef CONFIRM_COMPILATION_ERRORS #ifdef CONFIRM_COMPILATION_ERRORS
{ {
index<3> i1(0, 1); multi_span_index<3> i1(0, 1);
index<3> i2(0, 1, 2, 3); multi_span_index<3> i2(0, 1, 2, 3);
index<3> i3 = {0}; multi_span_index<3> i3 = {0};
index<3> i4 = {0, 1, 2, 3}; multi_span_index<3> i4 = {0, 1, 2, 3};
index<1> i5 = {0, 1}; multi_span_index<1> i5 = {0, 1};
} }
#endif #endif
} }
@ -1359,15 +1367,15 @@ TEST_CASE("index_operations")
{ {
ptrdiff_t a[3] = {0, 1, 2}; ptrdiff_t a[3] = {0, 1, 2};
ptrdiff_t b[3] = {3, 4, 5}; ptrdiff_t b[3] = {3, 4, 5};
index<3> i = a; multi_span_index<3> i = a;
index<3> j = b; multi_span_index<3> j = b;
CHECK(i[0] == 0); CHECK(i[0] == 0);
CHECK(i[1] == 1); CHECK(i[1] == 1);
CHECK(i[2] == 2); CHECK(i[2] == 2);
{ {
index<3> k = i + j; multi_span_index<3> k = i + j;
CHECK(i[0] == 0); CHECK(i[0] == 0);
CHECK(i[1] == 1); 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[0] == 0);
CHECK(i[1] == 1); 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[0] == 0);
CHECK(i[1] == 1); 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[0] == 0);
CHECK(i[1] == 1); CHECK(i[1] == 1);
@ -1423,7 +1431,7 @@ void iterate_second_column(multi_span<int, dynamic_range, dynamic_range> av)
} }
for (auto i = 0; i < section.size(); ++i) { 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]); CHECK(section[idx] == av[i][1]);
} }
@ -1431,7 +1439,7 @@ void iterate_second_column(multi_span<int, dynamic_range, dynamic_range> av)
CHECK(section.bounds().index_bounds()[1] == 1); CHECK(section.bounds().index_bounds()[1] == 1);
for (auto i = 0; i < section.bounds().index_bounds()[0]; ++i) { for (auto i = 0; i < section.bounds().index_bounds()[0]; ++i) {
for (auto j = 0; j < section.bounds().index_bounds()[1]; ++j) { 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]); CHECK(section[idx] == av[i][1]);
} }
} }

24
Telegram/ThirdParty/GSL/tests/notnull_tests.cpp vendored
View File

@ -14,13 +14,20 @@
// //
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#include <catch/catch.hpp> #include <catch/catch.hpp> // for AssertionHandler, StringRef, CHECK, TEST_...
#include <gsl/pointers> #include <gsl/pointers> // for not_null, operator<, operator<=, operator>
#include <memory> #include <algorithm> // for addressof
#include <string> #include <memory> // for shared_ptr, make_shared, operator<, opera...
#include <vector> #include <sstream> // for operator<<, ostringstream, basic_ostream:...
#include <stdint.h> // for uint16_t
#include <string> // for basic_string, operator==, string, operator<<
#include <typeinfo> // for type_info
namespace gsl {
struct fail_fast;
} // namespace gsl
using namespace gsl; using namespace gsl;
@ -127,6 +134,11 @@ TEST_CASE("TestNotNullConstructors")
not_null<std::shared_ptr<int>> x( not_null<std::shared_ptr<int>> x(
std::make_shared<int>(10)); // shared_ptr<int> is nullptr assignable std::make_shared<int>(10)); // shared_ptr<int> is nullptr assignable
#ifdef GSL_THROW_ON_CONTRACT_VIOLATION
int* pi = nullptr;
CHECK_THROWS_AS(not_null<decltype(pi)>(pi), fail_fast);
#endif
} }
template<typename T> template<typename T>
@ -315,3 +327,5 @@ TEST_CASE("TestNotNullCustomPtrComparison")
CHECK((NotNull1(p1) >= NotNull2(p2)) == (p1 >= p2)); CHECK((NotNull1(p1) >= NotNull2(p2)) == (p1 >= p2));
CHECK((NotNull2(p2) >= NotNull1(p1)) == (p2 >= p1)); CHECK((NotNull2(p2) >= NotNull1(p1)) == (p2 >= p1));
} }
static_assert(std::is_nothrow_move_constructible<not_null<void *>>::value, "not_null must be no-throw move constructible");

7
Telegram/ThirdParty/GSL/tests/owner_tests.cpp vendored
View File

@ -14,12 +14,9 @@
// //
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#include <catch/catch.hpp> #include <catch/catch.hpp> // for AssertionHandler, StringRef, CHECK, TEST_...
#include <gsl/pointers> #include <gsl/pointers> // for owner
#include <functional>
#include <memory>
using namespace gsl; using namespace gsl;

400
Telegram/ThirdParty/GSL/tests/span_tests.cpp vendored
View File

@ -14,17 +14,25 @@
// //
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#include <catch/catch.hpp> #include <catch/catch.hpp> // for AssertionHandler, StringRef, CHECK, TEST_...
#include <gsl/span> #include <gsl/gsl_byte> // for byte
#include <gsl/gsl_util> // for narrow_cast, at
#include <gsl/span> // for span, span_iterator, operator==, operator!=
#include <iostream> #include <array> // for array
#include <list> #include <iostream> // for ptrdiff_t
#include <map> #include <iterator> // for reverse_iterator, operator-, operator==
#include <memory> #include <memory> // for unique_ptr, shared_ptr, make_unique, allo...
#include <regex> #include <regex> // for match_results, sub_match, match_results<>...
#include <string> #include <stddef.h> // for ptrdiff_t
#include <vector> #include <string> // for string
#include <type_traits> // for integral_constant<>::value, is_default_co...
#include <vector> // for vector
namespace gsl {
struct fail_fast;
} // namespace gsl
using namespace std; using namespace std;
using namespace gsl; using namespace gsl;
@ -43,33 +51,33 @@ TEST_CASE("default_constructor")
{ {
{ {
span<int> s; span<int> s;
CHECK((s.length() == 0 && s.data() == nullptr)); CHECK((s.size() == 0 && s.data() == nullptr));
span<const int> cs; span<const int> cs;
CHECK((cs.length() == 0 && cs.data() == nullptr)); CHECK((cs.size() == 0 && cs.data() == nullptr));
} }
{ {
span<int, 0> s; span<int, 0> s;
CHECK((s.length() == 0 && s.data() == nullptr)); CHECK((s.size() == 0 && s.data() == nullptr));
span<const int, 0> cs; span<const int, 0> cs;
CHECK((cs.length() == 0 && cs.data() == nullptr)); CHECK((cs.size() == 0 && cs.data() == nullptr));
} }
{ {
#ifdef CONFIRM_COMPILATION_ERRORS #ifdef CONFIRM_COMPILATION_ERRORS
span<int, 1> s; span<int, 1> 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 #endif
} }
{ {
span<int> s{}; span<int> s{};
CHECK((s.length() == 0 && s.data() == nullptr)); CHECK((s.size() == 0 && s.data() == nullptr));
span<const int> cs{}; span<const int> 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") TEST_CASE("from_nullptr_size_constructor")
{
{
span<int> s = nullptr;
CHECK((s.length() == 0 && s.data() == nullptr));
span<const int> cs = nullptr;
CHECK((cs.length() == 0 && cs.data() == nullptr));
}
{
span<int, 0> s = nullptr;
CHECK((s.length() == 0 && s.data() == nullptr));
span<const int, 0> cs = nullptr;
CHECK((cs.length() == 0 && cs.data() == nullptr));
}
{
#ifdef CONFIRM_COMPILATION_ERRORS
span<int, 1> s = nullptr;
CHECK((s.length() == 1 && s.data() == nullptr)); // explains why it can't compile
#endif
}
{
span<int> s{nullptr};
CHECK((s.length() == 0 && s.data() == nullptr));
span<const int> cs{nullptr};
CHECK((cs.length() == 0 && cs.data() == nullptr));
}
{
span<int*> s{nullptr};
CHECK((s.length() == 0 && s.data() == nullptr));
span<const int*> cs{nullptr};
CHECK((cs.length() == 0 && cs.data() == nullptr));
}
}
TEST_CASE("from_nullptr_length_constructor")
{ {
{ {
span<int> s{nullptr, static_cast<span<int>::index_type>(0)}; span<int> s{nullptr, static_cast<span<int>::index_type>(0)};
CHECK((s.length() == 0 && s.data() == nullptr)); CHECK((s.size() == 0 && s.data() == nullptr));
span<const int> cs{nullptr, static_cast<span<int>::index_type>(0)}; span<const int> cs{nullptr, static_cast<span<int>::index_type>(0)};
CHECK((cs.length() == 0 && cs.data() == nullptr)); CHECK((cs.size() == 0 && cs.data() == nullptr));
} }
{ {
span<int, 0> s{nullptr, static_cast<span<int>::index_type>(0)}; span<int, 0> s{nullptr, static_cast<span<int>::index_type>(0)};
CHECK((s.length() == 0 && s.data() == nullptr)); CHECK((s.size() == 0 && s.data() == nullptr));
span<const int, 0> cs{nullptr, static_cast<span<int>::index_type>(0)}; span<const int, 0> cs{nullptr, static_cast<span<int>::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<int*> s{nullptr, static_cast<span<int>::index_type>(0)}; span<int*> s{nullptr, static_cast<span<int>::index_type>(0)};
CHECK((s.length() == 0 && s.data() == nullptr)); CHECK((s.size() == 0 && s.data() == nullptr));
span<const int*> cs{nullptr, static_cast<span<int>::index_type>(0)}; span<const int*> cs{nullptr, static_cast<span<int>::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<int> s = { &arr[0], i }; span<int> s = { &arr[0], i };
CHECK(s.length() == i); CHECK(s.size() == i);
CHECK(s.data() == &arr[0]); CHECK(s.data() == &arr[0]);
CHECK(s.empty() == (i == 0)); CHECK(s.empty() == (i == 0));
for (int j = 0; j < i; ++j) for (int j = 0; j < i; ++j)
@ -199,7 +165,7 @@ TEST_CASE("from_pointer_length_constructor")
} }
{ {
span<int> s = { &arr[i], 4-i }; span<int> s = { &arr[i], 4-i };
CHECK(s.length() == 4-i); CHECK(s.size() == 4-i);
CHECK(s.data() == &arr[i]); CHECK(s.data() == &arr[i]);
CHECK(s.empty() == (4-i == 0)); CHECK(s.empty() == (4-i == 0));
for (int j = 0; j < 4-i; ++j) for (int j = 0; j < 4-i; ++j)
@ -214,14 +180,14 @@ TEST_CASE("from_pointer_length_constructor")
{ {
span<int, 2> s{&arr[0], 2}; span<int, 2> 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)); CHECK((s[0] == 1 && s[1] == 2));
} }
{ {
int* p = nullptr; int* p = nullptr;
span<int> s{p, static_cast<span<int>::index_type>(0)}; span<int> s{p, static_cast<span<int>::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); 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)); CHECK((s[0] == 1 && s[1] == 2));
} }
{ {
int* p = nullptr; int* p = nullptr;
auto s = make_span(p, static_cast<span<int>::index_type>(0)); auto s = make_span(p, static_cast<span<int>::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<int> s{&arr[0], &arr[2]}; span<int> 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)); CHECK((s[0] == 1 && s[1] == 2));
} }
{ {
span<int, 2> s{&arr[0], &arr[2]}; span<int, 2> 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)); CHECK((s[0] == 1 && s[1] == 2));
} }
{ {
span<int> s{&arr[0], &arr[0]}; span<int> s{&arr[0], &arr[0]};
CHECK((s.length() == 0 && s.data() == &arr[0])); CHECK((s.size() == 0 && s.data() == &arr[0]));
} }
{ {
span<int, 0> s{&arr[0], &arr[0]}; span<int, 0> 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 // 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; int* p = nullptr;
span<int> s{p, p}; span<int> s{p, p};
CHECK((s.length() == 0 && s.data() == nullptr)); CHECK((s.size() == 0 && s.data() == nullptr));
} }
{ {
int* p = nullptr; int* p = nullptr;
span<int, 0> s{p, p}; span<int, 0> 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 // 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]); 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)); CHECK((s[0] == 1 && s[1] == 2));
} }
{ {
auto s = make_span(&arr[0], &arr[0]); 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; int* p = nullptr;
auto s = make_span(p, p); 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<int> s{arr}; span<int> s{arr};
CHECK((s.length() == 5 && s.data() == &arr[0])); CHECK((s.size() == 5 && s.data() == &arr[0]));
} }
{ {
span<int, 5> s{arr}; span<int, 5> 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}; int arr2d[2][3] = {1, 2, 3, 4, 5, 6};
@ -348,18 +314,18 @@ TEST_CASE("from_array_constructor")
{ {
span<int, 0> s{arr}; span<int, 0> s{arr};
CHECK((s.length() == 0 && s.data() == &arr[0])); CHECK((s.size() == 0 && s.data() == &arr[0]));
} }
{ {
span<int> s{arr2d}; span<int> 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)); CHECK((s[0] == 1 && s[5] == 6));
} }
{ {
span<int, 0> s{arr2d}; span<int, 0> 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 #endif
{ {
span<int[3]> s{&(arr2d[0]), 1}; span<int[3]> 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}; 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 #ifdef CONFIRM_COMPILATION_ERRORS
{ {
span<int> s{arr3d}; span<int> 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)); CHECK((s[0] == 1 && s[11] == 12));
} }
{ {
span<int, 0> s{arr3d}; span<int, 0> 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<int, 12> s{arr3d}; span<int, 12> 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)); CHECK((s[0] == 1 && s[5] == 6));
} }
#endif #endif
{ {
span<int[3][2]> s{&arr3d[0], 1}; span<int[3][2]> 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); 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); 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); 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<double> s(&arr[0][0][0], 10); span<double> 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); 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; delete[] arr;
@ -578,104 +544,6 @@ TEST_CASE("from_std_array_const_constructor")
} }
} }
TEST_CASE("from_unique_pointer_construction")
{
{
auto ptr = std::make_unique<int>(4);
{
span<int> 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<int>{nullptr};
{
span<int> 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<int[]>(4);
for (auto i = 0U; i < 4; i++) arr[i] = gsl::narrow_cast<int>(i + 1);
{
span<int> 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<int[]>{nullptr};
{
span<int> 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<int>(4);
{
span<int> 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<int>{nullptr};
{
span<int> 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") TEST_CASE("from_container_constructor")
{ {
std::vector<int> v = {1, 2, 3}; std::vector<int> v = {1, 2, 3};
@ -813,17 +681,17 @@ TEST_CASE("copy_move_and_assignment")
int arr[] = {3, 4, 5}; int arr[] = {3, 4, 5};
span<const int> s2 = arr; span<const int> s2 = arr;
CHECK((s2.length() == 3 && s2.data() == &arr[0])); CHECK((s2.size() == 3 && s2.data() == &arr[0]));
s2 = s1; s2 = s1;
CHECK(s2.empty()); CHECK(s2.empty());
auto get_temp_span = [&]() -> span<int> { return {&arr[1], 2}; }; auto get_temp_span = [&]() -> span<int> { return {&arr[1], 2}; };
auto use_span = [&](span<const int> s) { CHECK((s.length() == 2 && s.data() == &arr[1])); }; auto use_span = [&](span<const int> s) { CHECK((s.size() == 2 && s.data() == &arr[1])); };
use_span(get_temp_span()); use_span(get_temp_span());
s1 = 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") TEST_CASE("first")
@ -832,35 +700,35 @@ TEST_CASE("first")
{ {
span<int, 5> av = arr; span<int, 5> av = arr;
CHECK(av.first<2>().length() == 2); CHECK(av.first<2>().size() == 2);
CHECK(av.first(2).length() == 2); CHECK(av.first(2).size() == 2);
} }
{ {
span<int, 5> av = arr; span<int, 5> av = arr;
CHECK(av.first<0>().length() == 0); CHECK(av.first<0>().size() == 0);
CHECK(av.first(0).length() == 0); CHECK(av.first(0).size() == 0);
} }
{ {
span<int, 5> av = arr; span<int, 5> av = arr;
CHECK(av.first<5>().length() == 5); CHECK(av.first<5>().size() == 5);
CHECK(av.first(5).length() == 5); CHECK(av.first(5).size() == 5);
} }
{ {
span<int, 5> av = arr; span<int, 5> av = arr;
#ifdef CONFIRM_COMPILATION_ERRORS #ifdef CONFIRM_COMPILATION_ERRORS
CHECK(av.first<6>().length() == 6); CHECK(av.first<6>().size() == 6);
CHECK(av.first<-1>().length() == -1); CHECK(av.first<-1>().size() == -1);
#endif #endif
CHECK_THROWS_AS(av.first(6).length(), fail_fast); CHECK_THROWS_AS(av.first(6).size(), fail_fast);
} }
{ {
span<int> av; span<int> av;
CHECK(av.first<0>().length() == 0); CHECK(av.first<0>().size() == 0);
CHECK(av.first(0).length() == 0); CHECK(av.first(0).size() == 0);
} }
} }
@ -870,34 +738,34 @@ TEST_CASE("last")
{ {
span<int, 5> av = arr; span<int, 5> av = arr;
CHECK(av.last<2>().length() == 2); CHECK(av.last<2>().size() == 2);
CHECK(av.last(2).length() == 2); CHECK(av.last(2).size() == 2);
} }
{ {
span<int, 5> av = arr; span<int, 5> av = arr;
CHECK(av.last<0>().length() == 0); CHECK(av.last<0>().size() == 0);
CHECK(av.last(0).length() == 0); CHECK(av.last(0).size() == 0);
} }
{ {
span<int, 5> av = arr; span<int, 5> av = arr;
CHECK(av.last<5>().length() == 5); CHECK(av.last<5>().size() == 5);
CHECK(av.last(5).length() == 5); CHECK(av.last(5).size() == 5);
} }
{ {
span<int, 5> av = arr; span<int, 5> av = arr;
#ifdef CONFIRM_COMPILATION_ERRORS #ifdef CONFIRM_COMPILATION_ERRORS
CHECK(av.last<6>().length() == 6); CHECK(av.last<6>().size() == 6);
#endif #endif
CHECK_THROWS_AS(av.last(6).length(), fail_fast); CHECK_THROWS_AS(av.last(6).size(), fail_fast);
} }
{ {
span<int> av; span<int> av;
CHECK(av.last<0>().length() == 0); CHECK(av.last<0>().size() == 0);
CHECK(av.last(0).length() == 0); CHECK(av.last(0).size() == 0);
} }
} }
@ -907,64 +775,76 @@ TEST_CASE("subspan")
{ {
span<int, 5> av = arr; span<int, 5> av = arr;
CHECK((av.subspan<2, 2>().length() == 2)); CHECK((av.subspan<2, 2>().size() == 2));
CHECK(av.subspan(2, 2).length() == 2); CHECK(decltype(av.subspan<2, 2>())::extent == 2);
CHECK(av.subspan(2, 3).length() == 3); CHECK(av.subspan(2, 2).size() == 2);
CHECK(av.subspan(2, 3).size() == 3);
} }
{ {
span<int, 5> av = arr; span<int, 5> av = arr;
CHECK((av.subspan<0, 0>().length() == 0)); CHECK((av.subspan<0, 0>().size() == 0));
CHECK(av.subspan(0, 0).length() == 0); CHECK(decltype(av.subspan<0,0>())::extent == 0);
CHECK(av.subspan(0, 0).size() == 0);
} }
{ {
span<int, 5> av = arr; span<int, 5> av = arr;
CHECK((av.subspan<0, 5>().length() == 5)); CHECK((av.subspan<0, 5>().size() == 5));
CHECK(av.subspan(0, 5).length() == 5); CHECK(decltype(av.subspan<0, 5>())::extent == 5);
CHECK_THROWS_AS(av.subspan(0, 6).length(), fail_fast); CHECK(av.subspan(0, 5).size() == 5);
CHECK_THROWS_AS(av.subspan(1, 5).length(), fail_fast);
CHECK_THROWS_AS(av.subspan(0, 6).size(), fail_fast);
CHECK_THROWS_AS(av.subspan(1, 5).size(), fail_fast);
} }
{ {
span<int, 5> av = arr; span<int, 5> av = arr;
CHECK((av.subspan<4, 0>().length() == 0)); CHECK((av.subspan<4, 0>().size() == 0));
CHECK(av.subspan(4, 0).length() == 0); CHECK(decltype(av.subspan<4, 0>())::extent == 0);
CHECK(av.subspan(5, 0).length() == 0); CHECK(av.subspan(4, 0).size() == 0);
CHECK_THROWS_AS(av.subspan(6, 0).length(), fail_fast); CHECK(av.subspan(5, 0).size() == 0);
CHECK_THROWS_AS(av.subspan(6, 0).size(), fail_fast);
}
{
span<int, 5> av = arr;
CHECK((av.subspan<1>().size() == 4));
CHECK(decltype(av.subspan<1>())::extent == 4);
} }
{ {
span<int> av; span<int> av;
CHECK((av.subspan<0, 0>().length() == 0)); CHECK((av.subspan<0, 0>().size() == 0));
CHECK(av.subspan(0, 0).length() == 0); CHECK((decltype(av.subspan<0, 0>())::extent == 0));
CHECK_THROWS_AS((av.subspan<1, 0>().length()), fail_fast); CHECK(av.subspan(0, 0).size() == 0);
CHECK_THROWS_AS((av.subspan<1, 0>().size()), fail_fast);
} }
{ {
span<int> av; span<int> av;
CHECK(av.subspan(0).length() == 0); CHECK(av.subspan(0).size() == 0);
CHECK_THROWS_AS(av.subspan(1).length(), fail_fast); CHECK_THROWS_AS(av.subspan(1).size(), fail_fast);
} }
{ {
span<int> av = arr; span<int> av = arr;
CHECK(av.subspan(0).length() == 5); CHECK(av.subspan(0).size() == 5);
CHECK(av.subspan(1).length() == 4); CHECK(av.subspan(1).size() == 4);
CHECK(av.subspan(4).length() == 1); CHECK(av.subspan(4).size() == 1);
CHECK(av.subspan(5).length() == 0); CHECK(av.subspan(5).size() == 0);
CHECK_THROWS_AS(av.subspan(6).length(), fail_fast); CHECK_THROWS_AS(av.subspan(6).size(), fail_fast);
const auto av2 = av.subspan(1); const auto av2 = av.subspan(1);
for (int i = 0; i < 4; ++i) CHECK(av2[i] == i + 2); for (int i = 0; i < 4; ++i) CHECK(av2[i] == i + 2);
} }
{ {
span<int, 5> av = arr; span<int, 5> av = arr;
CHECK(av.subspan(0).length() == 5); CHECK(av.subspan(0).size() == 5);
CHECK(av.subspan(1).length() == 4); CHECK(av.subspan(1).size() == 4);
CHECK(av.subspan(4).length() == 1); CHECK(av.subspan(4).size() == 1);
CHECK(av.subspan(5).length() == 0); CHECK(av.subspan(5).size() == 0);
CHECK_THROWS_AS(av.subspan(6).length(), fail_fast); CHECK_THROWS_AS(av.subspan(6).size(), fail_fast);
const auto av2 = av.subspan(1); const auto av2 = av.subspan(1);
for (int i = 0; i < 4; ++i) CHECK(av2[i] == i + 2); for (int i = 0; i < 4; ++i) CHECK(av2[i] == i + 2);
} }
@ -1282,8 +1162,8 @@ TEST_CASE("crbegin_crend")
TEST_CASE("comparison_operators") TEST_CASE("comparison_operators")
{ {
{ {
span<int> s1 = nullptr; span<int> s1;
span<int> s2 = nullptr; span<int> s2;
CHECK(s1 == s2); CHECK(s1 == s2);
CHECK(!(s1 != s2)); CHECK(!(s1 != s2));
CHECK(!(s1 < s2)); CHECK(!(s1 < s2));
@ -1320,7 +1200,7 @@ TEST_CASE("comparison_operators")
{ {
int arr[] = {2, 1}; // bigger int arr[] = {2, 1}; // bigger
span<int> s1 = nullptr; span<int> s1;
span<int> s2 = arr; span<int> s2 = arr;
CHECK(s1 != s2); CHECK(s1 != s2);
@ -1405,17 +1285,17 @@ TEST_CASE("as_bytes")
{ {
const span<const int> s = a; const span<const int> s = a;
CHECK(s.length() == 4); CHECK(s.size() == 4);
const span<const byte> bs = as_bytes(s); const span<const byte> bs = as_bytes(s);
CHECK(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data())); CHECK(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data()));
CHECK(bs.length() == s.length_bytes()); CHECK(bs.size() == s.size_bytes());
} }
{ {
span<int> s; span<int> s;
const auto bs = as_bytes(s); const auto bs = as_bytes(s);
CHECK(bs.length() == s.length()); CHECK(bs.size() == s.size());
CHECK(bs.length() == 0); CHECK(bs.size() == 0);
CHECK(bs.size_bytes() == 0); CHECK(bs.size_bytes() == 0);
CHECK(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data())); CHECK(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data()));
CHECK(bs.data() == nullptr); CHECK(bs.data() == nullptr);
@ -1425,7 +1305,7 @@ TEST_CASE("as_bytes")
span<int> s = a; span<int> s = a;
const auto bs = as_bytes(s); const auto bs = as_bytes(s);
CHECK(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data())); CHECK(static_cast<const void*>(bs.data()) == static_cast<const void*>(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 #ifdef CONFIRM_COMPILATION_ERRORS
// you should not be able to get writeable bytes for const objects // you should not be able to get writeable bytes for const objects
span<const int> s = a; span<const int> s = a;
CHECK(s.length() == 4); CHECK(s.size() == 4);
span<const byte> bs = as_writeable_bytes(s); span<const byte> bs = as_writeable_bytes(s);
CHECK(static_cast<void*>(bs.data()) == static_cast<void*>(s.data())); CHECK(static_cast<void*>(bs.data()) == static_cast<void*>(s.data()));
CHECK(bs.length() == s.length_bytes()); CHECK(bs.size() == s.size_bytes());
#endif #endif
} }
{ {
span<int> s; span<int> s;
const auto bs = as_writeable_bytes(s); const auto bs = as_writeable_bytes(s);
CHECK(bs.length() == s.length()); CHECK(bs.size() == s.size());
CHECK(bs.length() == 0); CHECK(bs.size() == 0);
CHECK(bs.size_bytes() == 0); CHECK(bs.size_bytes() == 0);
CHECK(static_cast<void*>(bs.data()) == static_cast<void*>(s.data())); CHECK(static_cast<void*>(bs.data()) == static_cast<void*>(s.data()));
CHECK(bs.data() == nullptr); CHECK(bs.data() == nullptr);
@ -1458,7 +1338,7 @@ TEST_CASE("as_writeable_bytes")
span<int> s = a; span<int> s = a;
const auto bs = as_writeable_bytes(s); const auto bs = as_writeable_bytes(s);
CHECK(static_cast<void*>(bs.data()) == static_cast<void*>(s.data())); CHECK(static_cast<void*>(bs.data()) == static_cast<void*>(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 // converting to an span from an equal size array is ok
span<int, 4> s4 = arr; span<int, 4> s4 = arr;
CHECK(s4.length() == 4); CHECK(s4.size() == 4);
// converting to dynamic_range is always ok // converting to dynamic_range is always ok
{ {
span<int> s = s4; span<int> s = s4;
CHECK(s.length() == s4.length()); CHECK(s.size() == s4.size());
static_cast<void>(s); static_cast<void>(s);
} }

109
Telegram/ThirdParty/GSL/tests/strided_span_tests.cpp vendored
View File

@ -14,16 +14,21 @@
// //
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#include <catch/catch.hpp> #include <catch/catch.hpp> // for AssertionHandler, StringRef, CHECK, CHECK...
#include <gsl/multi_span> #include <gsl/gsl_byte> // for byte
#include <gsl/gsl_util> // for narrow_cast
#include <gsl/multi_span> // for strided_span, index, multi_span, strided_...
#include <iostream> #include <iostream> // for size_t
#include <list> #include <iterator> // for begin, end
#include <map> #include <numeric> // for iota
#include <memory> #include <type_traits> // for integral_constant<>::value, is_convertible
#include <string> #include <vector> // for vector
#include <vector>
namespace gsl {
struct fail_fast;
} // namespace gsl
using namespace std; using namespace std;
using namespace gsl; using namespace gsl;
@ -43,8 +48,8 @@ TEST_CASE("span_section_test")
int a[30][4][5]; int a[30][4][5];
const auto av = as_multi_span(a); const auto av = as_multi_span(a);
const auto sub = av.section({15, 0, 0}, gsl::index<3>{2, 2, 2}); 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::index<3>{1, 1, 1}); const auto subsub = sub.section({1, 0, 0}, gsl::multi_span_index<3>{1, 1, 1});
(void) subsub; (void) subsub;
} }
@ -74,18 +79,18 @@ TEST_CASE("strided_span_constructors")
const int carr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; const int carr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
strided_span<int, 1> sav1{arr, {{9}, {1}}}; // T -> T strided_span<int, 1> 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.bounds().stride() == 1);
CHECK((sav1[0] == 1 && sav1[8] == 9)); CHECK((sav1[0] == 1 && sav1[8] == 9));
strided_span<const int, 1> sav2{carr, {{4}, {2}}}; // const T -> const T strided_span<const int, 1> sav2{carr, {{4}, {2}}}; // const T -> const T
CHECK(sav2.bounds().index_bounds() == index<1>{4}); CHECK(sav2.bounds().index_bounds() == multi_span_index<1>{4});
CHECK(sav2.bounds().strides() == index<1>{2}); CHECK(sav2.bounds().strides() == multi_span_index<1>{2});
CHECK((sav2[0] == 1 && sav2[3] == 7)); CHECK((sav2[0] == 1 && sav2[3] == 7));
strided_span<int, 2> sav3{arr, {{2, 2}, {6, 2}}}; // T -> const T strided_span<int, 2> sav3{arr, {{2, 2}, {6, 2}}}; // T -> const T
CHECK((sav3.bounds().index_bounds() == index<2>{2, 2})); CHECK((sav3.bounds().index_bounds() == multi_span_index<2>{2, 2}));
CHECK((sav3.bounds().strides() == index<2>{6, 2})); CHECK((sav3.bounds().strides() == multi_span_index<2>{6, 2}));
CHECK((sav3[{0, 0}] == 1 && sav3[{0, 1}] == 3 && sav3[{1, 0}] == 7)); 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<int> src = arr; const multi_span<int> src = arr;
strided_span<int, 1> sav{src, {2, 1}}; strided_span<int, 1> sav{src, {2, 1}};
CHECK(sav.bounds().index_bounds() == index<1>{2}); CHECK(sav.bounds().index_bounds() == multi_span_index<1>{2});
CHECK(sav.bounds().strides() == index<1>{1}); CHECK(sav.bounds().strides() == multi_span_index<1>{1});
CHECK(sav[1] == 2); CHECK(sav[1] == 2);
#if _MSC_VER > 1800 #if _MSC_VER > 1800
@ -110,8 +115,8 @@ TEST_CASE("strided_span_constructors")
strided_span<const int, 1> sav_c{multi_span<const int>{src}, strided_span<const int, 1> sav_c{multi_span<const int>{src},
strided_bounds<1>{2, 1}}; strided_bounds<1>{2, 1}};
#endif #endif
CHECK(sav_c.bounds().index_bounds() == index<1>{2}); CHECK(sav_c.bounds().index_bounds() == multi_span_index<1>{2});
CHECK(sav_c.bounds().strides() == index<1>{1}); CHECK(sav_c.bounds().strides() == multi_span_index<1>{1});
CHECK(sav_c[1] == 2); CHECK(sav_c[1] == 2);
#if _MSC_VER > 1800 #if _MSC_VER > 1800
@ -120,8 +125,8 @@ TEST_CASE("strided_span_constructors")
strided_span<volatile int, 1> sav_v{multi_span<volatile int>{src}, strided_span<volatile int, 1> sav_v{multi_span<volatile int>{src},
strided_bounds<1>{2, 1}}; strided_bounds<1>{2, 1}};
#endif #endif
CHECK(sav_v.bounds().index_bounds() == index<1>{2}); CHECK(sav_v.bounds().index_bounds() == multi_span_index<1>{2});
CHECK(sav_v.bounds().strides() == index<1>{1}); CHECK(sav_v.bounds().strides() == multi_span_index<1>{1});
CHECK(sav_v[1] == 2); CHECK(sav_v[1] == 2);
#if _MSC_VER > 1800 #if _MSC_VER > 1800
@ -130,8 +135,8 @@ TEST_CASE("strided_span_constructors")
strided_span<const volatile int, 1> sav_cv{multi_span<const volatile int>{src}, strided_span<const volatile int, 1> sav_cv{multi_span<const volatile int>{src},
strided_bounds<1>{2, 1}}; strided_bounds<1>{2, 1}};
#endif #endif
CHECK(sav_cv.bounds().index_bounds() == index<1>{2}); CHECK(sav_cv.bounds().index_bounds() == multi_span_index<1>{2});
CHECK(sav_cv.bounds().strides() == index<1>{1}); CHECK(sav_cv.bounds().strides() == multi_span_index<1>{1});
CHECK(sav_cv[1] == 2); CHECK(sav_cv[1] == 2);
} }
@ -140,8 +145,8 @@ TEST_CASE("strided_span_constructors")
const multi_span<const int> src{arr}; const multi_span<const int> src{arr};
strided_span<const int, 1> sav_c{src, {2, 1}}; strided_span<const int, 1> sav_c{src, {2, 1}};
CHECK(sav_c.bounds().index_bounds() == index<1>{2}); CHECK(sav_c.bounds().index_bounds() == multi_span_index<1>{2});
CHECK(sav_c.bounds().strides() == index<1>{1}); CHECK(sav_c.bounds().strides() == multi_span_index<1>{1});
CHECK(sav_c[1] == 2); CHECK(sav_c[1] == 2);
#if _MSC_VER > 1800 #if _MSC_VER > 1800
@ -151,8 +156,8 @@ TEST_CASE("strided_span_constructors")
strided_bounds<1>{2, 1}}; strided_bounds<1>{2, 1}};
#endif #endif
CHECK(sav_cv.bounds().index_bounds() == index<1>{2}); CHECK(sav_cv.bounds().index_bounds() == multi_span_index<1>{2});
CHECK(sav_cv.bounds().strides() == index<1>{1}); CHECK(sav_cv.bounds().strides() == multi_span_index<1>{1});
CHECK(sav_cv[1] == 2); CHECK(sav_cv[1] == 2);
} }
@ -161,8 +166,8 @@ TEST_CASE("strided_span_constructors")
const multi_span<volatile int> src{arr}; const multi_span<volatile int> src{arr};
strided_span<volatile int, 1> sav_v{src, {2, 1}}; strided_span<volatile int, 1> sav_v{src, {2, 1}};
CHECK(sav_v.bounds().index_bounds() == index<1>{2}); CHECK(sav_v.bounds().index_bounds() == multi_span_index<1>{2});
CHECK(sav_v.bounds().strides() == index<1>{1}); CHECK(sav_v.bounds().strides() == multi_span_index<1>{1});
CHECK(sav_v[1] == 2); CHECK(sav_v[1] == 2);
#if _MSC_VER > 1800 #if _MSC_VER > 1800
@ -171,8 +176,8 @@ TEST_CASE("strided_span_constructors")
strided_span<const volatile int, 1> sav_cv{multi_span<const volatile int>{src}, strided_span<const volatile int, 1> sav_cv{multi_span<const volatile int>{src},
strided_bounds<1>{2, 1}}; strided_bounds<1>{2, 1}};
#endif #endif
CHECK(sav_cv.bounds().index_bounds() == index<1>{2}); CHECK(sav_cv.bounds().index_bounds() == multi_span_index<1>{2});
CHECK(sav_cv.bounds().strides() == index<1>{1}); CHECK(sav_cv.bounds().strides() == multi_span_index<1>{1});
CHECK(sav_cv[1] == 2); CHECK(sav_cv[1] == 2);
} }
@ -181,8 +186,8 @@ TEST_CASE("strided_span_constructors")
const multi_span<const volatile int> src{arr}; const multi_span<const volatile int> src{arr};
strided_span<const volatile int, 1> sav_cv{src, {2, 1}}; strided_span<const volatile int, 1> sav_cv{src, {2, 1}};
CHECK(sav_cv.bounds().index_bounds() == index<1>{2}); CHECK(sav_cv.bounds().index_bounds() == multi_span_index<1>{2});
CHECK(sav_cv.bounds().strides() == index<1>{1}); CHECK(sav_cv.bounds().strides() == multi_span_index<1>{1});
CHECK(sav_cv[1] == 2); CHECK(sav_cv[1] == 2);
} }
} }
@ -201,7 +206,7 @@ TEST_CASE("strided_span_constructors")
const strided_span<int, 1> src{arr, {2, 1}}; const strided_span<int, 1> src{arr, {2, 1}};
strided_span<const int, 1> sav{src}; strided_span<const int, 1> 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.bounds().stride() == 1);
CHECK(sav[1] == 5); CHECK(sav[1] == 5);
@ -216,15 +221,15 @@ TEST_CASE("strided_span_constructors")
const strided_span<int, 1> src1{arr1, {2, 1}}; const strided_span<int, 1> src1{arr1, {2, 1}};
strided_span<int, 1> sav1{src1}; strided_span<int, 1> 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.bounds().stride() == 1);
CHECK(sav1[0] == 3); CHECK(sav1[0] == 3);
int arr2[6] = {1, 2, 3, 4, 5, 6}; int arr2[6] = {1, 2, 3, 4, 5, 6};
const strided_span<const int, 2> src2{arr2, {{3, 2}, {2, 1}}}; const strided_span<const int, 2> src2{arr2, {{3, 2}, {2, 1}}};
strided_span<const int, 2> sav2{src2}; strided_span<const int, 2> sav2{src2};
CHECK((sav2.bounds().index_bounds() == index<2>{3, 2})); CHECK((sav2.bounds().index_bounds() == multi_span_index<2>{3, 2}));
CHECK((sav2.bounds().strides() == index<2>{2, 1})); CHECK((sav2.bounds().strides() == multi_span_index<2>{2, 1}));
CHECK((sav2[{0, 0}] == 1 && sav2[{2, 0}] == 5)); CHECK((sav2[{0, 0}] == 1 && sav2[{2, 0}] == 5));
} }
@ -236,8 +241,8 @@ TEST_CASE("strided_span_constructors")
const strided_span<int, 1> src{arr1, {{2}, {1}}}; const strided_span<int, 1> src{arr1, {{2}, {1}}};
strided_span<const int, 1> sav{arr2, {{3}, {2}}}; strided_span<const int, 1> sav{arr2, {{3}, {2}}};
strided_span<const int, 1>& sav_ref = (sav = src); strided_span<const int, 1>& sav_ref = (sav = src);
CHECK(sav.bounds().index_bounds() == index<1>{2}); CHECK(sav.bounds().index_bounds() == multi_span_index<1>{2});
CHECK(sav.bounds().strides() == index<1>{1}); CHECK(sav.bounds().strides() == multi_span_index<1>{1});
CHECK(sav[0] == 1); CHECK(sav[0] == 1);
CHECK(&sav_ref == &sav); CHECK(&sav_ref == &sav);
} }
@ -249,8 +254,8 @@ TEST_CASE("strided_span_constructors")
const strided_span<int, 1> src1{arr1, {2, 1}}; const strided_span<int, 1> src1{arr1, {2, 1}};
strided_span<int, 1> sav1{arr1b, {1, 1}}; strided_span<int, 1> sav1{arr1b, {1, 1}};
strided_span<int, 1>& sav1_ref = (sav1 = src1); strided_span<int, 1>& sav1_ref = (sav1 = src1);
CHECK(sav1.bounds().index_bounds() == index<1>{2}); CHECK(sav1.bounds().index_bounds() == multi_span_index<1>{2});
CHECK(sav1.bounds().strides() == index<1>{1}); CHECK(sav1.bounds().strides() == multi_span_index<1>{1});
CHECK(sav1[0] == 3); CHECK(sav1[0] == 3);
CHECK(&sav1_ref == &sav1); CHECK(&sav1_ref == &sav1);
@ -259,8 +264,8 @@ TEST_CASE("strided_span_constructors")
const strided_span<const int, 2> src2{arr2, {{3, 2}, {2, 1}}}; const strided_span<const int, 2> src2{arr2, {{3, 2}, {2, 1}}};
strided_span<const int, 2> sav2{arr2b, {{1, 1}, {1, 1}}}; strided_span<const int, 2> sav2{arr2b, {{1, 1}, {1, 1}}};
strided_span<const int, 2>& sav2_ref = (sav2 = src2); strided_span<const int, 2>& sav2_ref = (sav2 = src2);
CHECK((sav2.bounds().index_bounds() == index<2>{3, 2})); CHECK((sav2.bounds().index_bounds() == multi_span_index<2>{3, 2}));
CHECK((sav2.bounds().strides() == index<2>{2, 1})); CHECK((sav2.bounds().strides() == multi_span_index<2>{2, 1}));
CHECK((sav2[{0, 0}] == 1 && sav2[{2, 0}] == 5)); CHECK((sav2[{0, 0}] == 1 && sav2[{2, 0}] == 5));
CHECK(&sav2_ref == &sav2); CHECK(&sav2_ref == &sav2);
} }
@ -317,7 +322,7 @@ TEST_CASE("strided_span_column_major")
// Section // Section
strided_span<int, 2> cm_sec = cm_sav.section({2, 1}, {3, 2}); strided_span<int, 2> 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, 0}] == 8));
CHECK((cm_sec[{0, 1}] == 9)); CHECK((cm_sec[{0, 1}] == 9));
CHECK((cm_sec[{1, 0}] == 11)); CHECK((cm_sec[{1, 0}] == 11));
@ -366,7 +371,7 @@ TEST_CASE("strided_span_bounds")
{ {
// strided array ctor with matching strided bounds // strided array ctor with matching strided bounds
strided_span<int, 1> sav{arr, {4, 1}}; strided_span<int, 1> 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(sav[3] == 3);
CHECK_THROWS_AS(sav[4], fail_fast); CHECK_THROWS_AS(sav[4], fail_fast);
} }
@ -374,7 +379,7 @@ TEST_CASE("strided_span_bounds")
{ {
// strided array ctor with smaller strided bounds // strided array ctor with smaller strided bounds
strided_span<int, 1> sav{arr, {2, 1}}; strided_span<int, 1> 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(sav[1] == 1);
CHECK_THROWS_AS(sav[2], fail_fast); CHECK_THROWS_AS(sav[2], fail_fast);
} }
@ -382,7 +387,7 @@ TEST_CASE("strided_span_bounds")
{ {
// strided array ctor with fitting irregular bounds // strided array ctor with fitting irregular bounds
strided_span<int, 1> sav{arr, {2, 3}}; strided_span<int, 1> 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[0] == 0);
CHECK(sav[1] == 3); CHECK(sav[1] == 3);
CHECK_THROWS_AS(sav[2], fail_fast); CHECK_THROWS_AS(sav[2], fail_fast);
@ -428,7 +433,7 @@ TEST_CASE("strided_span_bounds")
strided_span<int, 2> sav7{av.as_multi_span(dim<2>(), dim<2>()), strided_span<int, 2> sav7{av.as_multi_span(dim<2>(), dim<2>()),
{{1, 1}, {1, 1}, {1, 1}}}; {{1, 1}, {1, 1}, {1, 1}}};
index<1> index{0, 1}; multi_span_index<1> index{0, 1};
strided_span<int, 1> sav8{arr, {1, {1, 1}}}; strided_span<int, 1> sav8{arr, {1, {1, 1}}};
strided_span<int, 1> sav9{arr, {{1, 1}, {1, 1}}}; strided_span<int, 1> sav9{arr, {{1, 1}, {1, 1}}};
strided_span<int, 1> sav10{av, {1, {1, 1}}}; strided_span<int, 1> sav10{av, {1, {1, 1}}};
@ -543,7 +548,7 @@ TEST_CASE("empty_strided_spans")
multi_span<int, 0> empty_av(nullptr); multi_span<int, 0> empty_av(nullptr);
strided_span<int, 1> empty_sav{empty_av, {0, 1}}; strided_span<int, 1> 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[0], fail_fast);
CHECK_THROWS_AS(empty_sav.begin()[0], fail_fast); CHECK_THROWS_AS(empty_sav.begin()[0], fail_fast);
CHECK_THROWS_AS(empty_sav.cbegin()[0], fail_fast); CHECK_THROWS_AS(empty_sav.cbegin()[0], fail_fast);
@ -557,7 +562,7 @@ TEST_CASE("empty_strided_spans")
{ {
strided_span<int, 1> empty_sav{nullptr, 0, {0, 1}}; strided_span<int, 1> 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[0], fail_fast);
CHECK_THROWS_AS(empty_sav.begin()[0], fail_fast); CHECK_THROWS_AS(empty_sav.begin()[0], fail_fast);
CHECK_THROWS_AS(empty_sav.cbegin()[0], fail_fast); CHECK_THROWS_AS(empty_sav.cbegin()[0], fail_fast);
@ -577,7 +582,7 @@ void iterate_every_other_element(multi_span<int, dynamic_range> av)
#if _MSC_VER > 1800 #if _MSC_VER > 1800
auto bounds = strided_bounds<1>({length}, {2}); auto bounds = strided_bounds<1>({length}, {2});
#else #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 #endif
strided_span<int, 1> strided(&av.data()[1], av.size() - 1, bounds); strided_span<int, 1> strided(&av.data()[1], av.size() - 1, bounds);
@ -633,7 +638,7 @@ void iterate_second_slice(multi_span<int, dynamic_range, dynamic_range, dynamic_
for (auto i = 0; i < section.extent<0>(); ++i) { for (auto i = 0; i < section.extent<0>(); ++i) {
for (auto j = 0; j < section.extent<1>(); ++j) for (auto j = 0; j < section.extent<1>(); ++j)
for (auto k = 0; k < section.extent<2>(); ++k) { 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]); CHECK(section[idx] == expected[2 * i + 2 * j + k]);
} }
} }

24
Telegram/ThirdParty/GSL/tests/string_span_tests.cpp vendored
View File

@ -14,15 +14,19 @@
// //
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#include <catch/catch.hpp> #include <catch/catch.hpp> // for AssertionHandler, StringRef, CHECK, TEST_...
#include <gsl/gsl> //owner #include <gsl/gsl_assert> // for Expects, fail_fast (ptr only)
#include <gsl/string_span> #include <gsl/pointers> // for owner
#include <gsl/span> // for span, dynamic_extent
#include <gsl/string_span> // for basic_string_span, operator==, ensure_z
#include <algorithm> #include <algorithm> // for move, find
#include <cstdlib> #include <cstddef> // for size_t
#include <map> #include <map> // for map
#include <vector> #include <string> // for basic_string, string, char_traits, operat...
#include <type_traits> // for remove_reference<>::type
#include <vector> // for vector, allocator
using namespace std; using namespace std;
using namespace gsl; using namespace gsl;
@ -507,12 +511,6 @@ TEST_CASE("Constructors")
CHECK(span.length() == 0); CHECK(span.length() == 0);
} }
// from nullptr
{
cstring_span<> span(nullptr);
CHECK(span.length() == 0);
}
// from string literal // from string literal
{ {
cstring_span<> span = "Hello"; cstring_span<> span = "Hello";

16
Telegram/ThirdParty/GSL/tests/utils_tests.cpp vendored
View File

@ -14,14 +14,24 @@
// //
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#include <catch/catch.hpp> #include <catch/catch.hpp> // for AssertionHandler, StringRef, CHECK, TEST_...
#include <gsl/gsl> #include <gsl/gsl_util> // for narrow, finally, narrow_cast, narrowing_e...
#include <functional> #include <algorithm> // for move
#include <functional> // for reference_wrapper, _Bind_helper<>::type
#include <limits> // for numeric_limits
#include <stdint.h> // for uint32_t, int32_t
#include <type_traits> // for is_same
using namespace gsl; using namespace gsl;
TEST_CASE("sanity check for gsl::index typedef")
{
static_assert(std::is_same<gsl::index, std::ptrdiff_t>::value,
"gsl::index represents wrong arithmetic type");
}
void f(int& i) { i += 1; } void f(int& i) { i += 1; }
TEST_CASE("finally_lambda") TEST_CASE("finally_lambda")