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]
remote = https://github.com/Microsoft/GSL.git
branch = master
commit = 1c95f9436eae69c9b9315911ef6aa210df7d1e31
parent = 0dde6bbc3b558644359e5ee49725e508babcea8b
commit = c9e423d7cf2afb88672e31f55e4b30c53be7aae3
parent = dde6ba57a8584fda72b205bd8aff8ce452bdc8de
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)
@ -16,7 +16,7 @@ endif ()
# when minimum version required is 3.8.0 remove if below
# both branches do exactly the same thing
if (CMAKE_MAJOR_VERSION VERSION_LESS 3.7.9)
if (CMAKE_VERSION VERSION_LESS 3.7.9)
if (NOT MSVC)
include(CheckCXXCompilerFlag)
CHECK_CXX_COMPILER_FLAG("-std=c++14" COMPILER_SUPPORTS_CXX14)
@ -49,10 +49,18 @@ target_include_directories(GSL INTERFACE
>
)
if (MSVC_IDE)
option(VS_ADD_NATIVE_VISUALIZERS "Configure project to use Visual Studio native visualizers" TRUE)
else()
set(VS_ADD_NATIVE_VISUALIZERS FALSE CACHE INTERNAL "Native visualizers are Visual Studio extension" FORCE)
endif()
# add natvis file to the library so it will automatically be loaded into Visual Studio
target_sources(GSL INTERFACE
${CMAKE_CURRENT_SOURCE_DIR}/GSL.natvis
)
if(VS_ADD_NATIVE_VISUALIZERS)
target_sources(GSL INTERFACE
${CMAKE_CURRENT_SOURCE_DIR}/GSL.natvis
)
endif()
install(
DIRECTORY include/gsl

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

@ -11,7 +11,7 @@
</Type>
<!-- 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>
<Expand>
<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 Sierra 10.12.4 using Apple LLVM version 8.1.0 (Clang-802.0.42)
* OS X El Capitan (10.11) using Xcode with AppleClang 8.0.0.8000042
* OS X High Sierra 10.13.2 (17C88) using Apple LLVM version 9.0.0 (clang-900.0.39.2)
* FreeBSD 10.x with Clang/LLVM 3.6
> If you successfully port GSL to another platform, we would love to hear from you. Please submit an issue to let us know. Also please consider
@ -44,7 +45,7 @@ contributing any changes that were necessary back to this project to benefit the
## Building the tests
To build the tests, you will require the following:
* [CMake](http://cmake.org), version 3.1.3 or later to be installed and in your PATH.
* [CMake](http://cmake.org), version 3.7 or later to be installed and in your PATH.
These steps assume the source code of this repository has been cloned into a directory named `c:\GSL`.

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

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

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

@ -17,9 +17,12 @@
#ifndef 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
#pragma warning(push)

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

@ -18,7 +18,7 @@
#define GSL_CONTRACTS_H
#include <exception>
#include <stdexcept>
#include <stdexcept> // for logic_error
//
// There are three configuration options for this GSL implementation's behavior
@ -52,12 +52,10 @@
//
#ifdef _MSC_VER
#define GSL_ASSUME(cond) __assume(cond)
#elif defined(__clang__)
#define GSL_ASSUME(cond) __builtin_assume(cond)
#elif defined(__GNUC__)
#define GSL_ASSUME(cond) ((cond) ? static_cast<void>(0) : __builtin_unreachable())
#else
#define GSL_ASSUME(cond) static_cast<void>(!!(cond))
#define GSL_ASSUME(cond) static_cast<void>((cond) ? 0 : 0)
#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>>
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);
}
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);
}
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);
}
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);
}
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));
}
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));
}
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));
}
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));
}
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));
}
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));
}
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>>
inline constexpr IntegerType to_integer(byte b) noexcept
constexpr IntegerType to_integer(byte b) noexcept
{
return static_cast<IntegerType>(b);
}
@ -138,7 +138,7 @@ inline constexpr IntegerType to_integer(byte b) noexcept
#endif // GSL_USE_STD_BYTE
template <bool E, typename T>
inline constexpr byte to_byte_impl(T t) noexcept
constexpr byte to_byte_impl(T t) noexcept
{
static_assert(
E, "gsl::to_byte(t) must be provided an unsigned char, otherwise data loss may occur. "
@ -146,19 +146,19 @@ inline constexpr byte to_byte_impl(T t) noexcept
return static_cast<byte>(t);
}
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);
}
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);
}
template <int I>
inline constexpr byte to_byte() noexcept
constexpr byte to_byte() noexcept
{
static_assert(I >= 0 && I <= 255,
"gsl::byte only has 8 bits of storage, values must be in range 0-255");

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

@ -17,12 +17,14 @@
#ifndef GSL_UTIL_H
#define GSL_UTIL_H
#include <gsl/gsl_assert> // Ensures/Expects
#include <gsl/gsl_assert> // for Expects
#include <array>
#include <exception>
#include <type_traits>
#include <utility>
#include <cstddef> // for ptrdiff_t, size_t
#include <exception> // for exception
#include <initializer_list> // for initializer_list
#include <type_traits> // for is_signed, integral_constant
#include <utility> // for forward
#if defined(_MSC_VER)
@ -41,47 +43,51 @@ namespace gsl
// GSL.util: utilities
//
// final_act allows you to ensure something gets run at the end of a scope
// index type for all container indexes/subscripts/sizes
using index = std::ptrdiff_t;
// final_action allows you to ensure something gets run at the end of a scope
template <class F>
class final_act
class final_action
{
public:
explicit final_act(F f) noexcept : f_(std::move(f)), invoke_(true) {}
explicit final_action(F f) noexcept : f_(std::move(f)) {}
final_act(final_act&& other) noexcept : f_(std::move(other.f_)), invoke_(other.invoke_)
final_action(final_action&& other) noexcept : f_(std::move(other.f_)), invoke_(other.invoke_)
{
other.invoke_ = false;
}
final_act(const final_act&) = delete;
final_act& operator=(const final_act&) = delete;
final_action(const final_action&) = delete;
final_action& operator=(const final_action&) = delete;
~final_act() noexcept
~final_action() noexcept
{
if (invoke_) f_();
}
private:
F f_;
bool invoke_;
bool invoke_ {true};
};
// finally() - convenience function to generate a final_act
// finally() - convenience function to generate a final_action
template <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>
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
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));
}
@ -101,7 +107,7 @@ namespace details
// narrow() : a checked version of narrow_cast() that throws if the cast changed the value
template <class T, class U>
inline T narrow(U u)
T narrow(U u)
{
T t = narrow_cast<T>(u);
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
//
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));
return arr[static_cast<std::size_t>(index)];
Expects(i >= 0 && i < narrow_cast<index>(N));
return arr[static_cast<std::size_t>(i)];
}
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());
return cont[static_cast<size_type>(index)];
return cont[static_cast<size_type>(i)];
}
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()));
return *(cont.begin() + index);
Expects(i >= 0 && i < narrow_cast<index>(cont.size()));
return *(cont.begin() + i);
}
} // namespace gsl

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

@ -17,22 +17,24 @@
#ifndef GSL_MULTI_SPAN_H
#define GSL_MULTI_SPAN_H
#include <gsl/gsl_assert>
#include <gsl/gsl_byte>
#include <gsl/gsl_util>
#include <gsl/gsl_assert> // for Expects
#include <gsl/gsl_byte> // for byte
#include <gsl/gsl_util> // for narrow_cast
#include <algorithm>
#include <array>
#include <algorithm> // for transform, lexicographical_compare
#include <array> // for array
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <iterator>
#include <limits>
#include <cstddef> // for ptrdiff_t, size_t, nullptr_t
#include <cstdint> // for PTRDIFF_MAX
#include <functional> // for divides, multiplies, minus, negate, plus
#include <initializer_list> // for initializer_list
#include <iterator> // for iterator, random_access_iterator_tag
#include <limits> // for numeric_limits
#include <new>
#include <numeric>
#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>
#ifdef _MSC_VER
@ -83,12 +85,12 @@ namespace details
}
template <std::size_t Rank>
class index final
class multi_span_index final
{
static_assert(Rank > 0, "Rank must be greater than 0!");
template <std::size_t OtherRank>
friend class index;
friend class multi_span_index;
public:
static const std::size_t rank = Rank;
@ -97,22 +99,22 @@ public:
using reference = std::add_lvalue_reference_t<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);
}
template <typename... Ts, typename = std::enable_if_t<(sizeof...(Ts) == Rank) &&
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
constexpr reference operator[](std::size_t component_idx)
@ -128,75 +130,75 @@ public:
return elems[component_idx];
}
constexpr bool operator==(const index& rhs) const GSL_NOEXCEPT
constexpr bool operator==(const multi_span_index& rhs) const GSL_NOEXCEPT
{
return std::equal(elems, elems + rank, rhs.elems);
}
constexpr bool operator!=(const index& rhs) const GSL_NOEXCEPT { return !(this == rhs); }
constexpr bool operator!=(const multi_span_index& rhs) const GSL_NOEXCEPT { return !(*this == rhs); }
constexpr index operator+() const GSL_NOEXCEPT { return *this; }
constexpr multi_span_index operator+() const GSL_NOEXCEPT { return *this; }
constexpr index operator-() const GSL_NOEXCEPT
constexpr multi_span_index operator-() const GSL_NOEXCEPT
{
index ret = *this;
multi_span_index ret = *this;
std::transform(ret, ret + rank, ret, std::negate<value_type>{});
return ret;
}
constexpr index operator+(const index& rhs) const GSL_NOEXCEPT
constexpr multi_span_index operator+(const multi_span_index& rhs) const GSL_NOEXCEPT
{
index ret = *this;
multi_span_index ret = *this;
ret += rhs;
return ret;
}
constexpr index operator-(const index& rhs) const GSL_NOEXCEPT
constexpr multi_span_index operator-(const multi_span_index& rhs) const GSL_NOEXCEPT
{
index ret = *this;
multi_span_index ret = *this;
ret -= rhs;
return ret;
}
constexpr index& operator+=(const index& rhs) GSL_NOEXCEPT
constexpr multi_span_index& operator+=(const multi_span_index& rhs) GSL_NOEXCEPT
{
std::transform(elems, elems + rank, rhs.elems, elems, std::plus<value_type>{});
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>{});
return *this;
}
constexpr index operator*(value_type v) const GSL_NOEXCEPT
constexpr multi_span_index operator*(value_type v) const GSL_NOEXCEPT
{
index ret = *this;
multi_span_index ret = *this;
ret *= v;
return ret;
}
constexpr index operator/(value_type v) const GSL_NOEXCEPT
constexpr multi_span_index operator/(value_type v) const GSL_NOEXCEPT
{
index ret = *this;
multi_span_index ret = *this;
ret /= v;
return ret;
}
friend constexpr index operator*(value_type v, const index& rhs) GSL_NOEXCEPT
friend constexpr multi_span_index operator*(value_type v, const multi_span_index& rhs) GSL_NOEXCEPT
{
return rhs * v;
}
constexpr index& operator*=(value_type v) GSL_NOEXCEPT
constexpr multi_span_index& operator*=(value_type v) GSL_NOEXCEPT
{
std::transform(elems, elems + rank, elems,
[v](value_type x) { return std::multiplies<value_type>{}(x, v); });
return *this;
}
constexpr index& operator/=(value_type v) GSL_NOEXCEPT
constexpr multi_span_index& operator/=(value_type v) GSL_NOEXCEPT
{
std::transform(elems, elems + rank, elems,
[v](value_type x) { return std::divides<value_type>{}(x, v); });
@ -495,8 +497,8 @@ namespace details
}
template <std::size_t Rank, bool Enabled = (Rank > 1),
typename Ret = std::enable_if_t<Enabled, index<Rank - 1>>>
inline constexpr Ret shift_left(const index<Rank>& other) GSL_NOEXCEPT
typename Ret = std::enable_if_t<Enabled, multi_span_index<Rank - 1>>>
constexpr Ret shift_left(const multi_span_index<Rank>& other) GSL_NOEXCEPT
{
Ret ret{};
for (std::size_t i = 0; i < Rank - 1; ++i) {
@ -533,7 +535,7 @@ public:
static const std::ptrdiff_t static_size = MyRanges::TotalSize;
using size_type = std::ptrdiff_t;
using index_type = index<rank>;
using index_type = multi_span_index<rank>;
using const_index_type = std::add_const_t<index_type>;
using 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;
}
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>
@ -696,7 +698,7 @@ public:
using const_reference = std::add_const_t<reference>;
using size_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 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>
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:
static const std::size_t rank = IndexType::rank;
using typename Base::reference;
using typename Base::pointer;
using typename Base::difference_type;
using typename Base::value_type;
using iterator_category = std::random_access_iterator_tag;
using value_type = IndexType;
using difference_type = std::ptrdiff_t;
using pointer = value_type*;
using reference = value_type&;
using index_type = value_type;
using index_size_type = typename IndexType::value_type;
template <typename Bounds>
@ -996,7 +996,7 @@ bounds_iterator<IndexType> operator+(typename bounds_iterator<IndexType>::differ
namespace details
{
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,
typename Bounds::index_type>
make_stride(const Bounds& bnd) GSL_NOEXCEPT
@ -1006,7 +1006,7 @@ namespace details
// Make a stride vector from bounds, assuming contiguous memory.
template <typename Bounds>
inline constexpr std::enable_if_t<
constexpr std::enable_if_t<
std::is_same<typename Bounds::mapping_type, contiguous_mapping_tag>::value,
typename Bounds::index_type>
make_stride(const Bounds& bnd) GSL_NOEXCEPT
@ -1052,17 +1052,17 @@ struct dim_t<dynamic_range>
{
static const std::ptrdiff_t value = dynamic_range;
const std::ptrdiff_t dvalue;
dim_t(std::ptrdiff_t size) : dvalue(size) {}
constexpr dim_t(std::ptrdiff_t size) GSL_NOEXCEPT : dvalue(size) {}
};
template <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>();
}
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);
}
@ -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,
std::ptrdiff_t... RestDimensions>
class multi_span;
template <typename ValueType, std::size_t Rank>
class strided_span;
@ -1479,15 +1478,15 @@ public:
constexpr pointer data() const GSL_NOEXCEPT { return data_; }
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>
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)...};
return this->operator[](idx);
}
@ -1600,7 +1599,7 @@ public:
// DimCount and Enabled here are workarounds for a bug in MSVC 2015
template <typename SpanType, typename... Dimensions2, std::size_t DimCount = sizeof...(Dimensions2),
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...>
{
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
// to the standard GSL interface.
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<
const U, static_cast<std::ptrdiff_t>(
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
// to the standard GSL interface.
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<byte, Dimensions...>::bounds_type::static_size != dynamic_range
? 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>
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...>
{
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>
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
{
return {reinterpret_cast<std::remove_all_extents_t<T>*>(arr), len};
}
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};
}
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};
}
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>
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};
}
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};
}
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,
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>
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,
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
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>
{
Expects(str.size() < PTRDIFF_MAX);
@ -1996,14 +1995,13 @@ private:
template <class Span>
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:
using typename Base::reference;
using typename Base::pointer;
using typename Base::difference_type;
using iterator_category = std::random_access_iterator_tag;
using value_type = typename Span::value_type;
using difference_type = std::ptrdiff_t;
using pointer = value_type*;
using reference = value_type&;
private:
template <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>
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:
using typename Base::reference;
using typename Base::pointer;
using typename Base::difference_type;
using typename Base::value_type;
using iterator_category = std::random_access_iterator_tag;
using value_type = typename Span::value_type;
using difference_type = std::ptrdiff_t;
using pointer = value_type*;
using reference = value_type&;
private:
template <typename ValueType, std::size_t Rank>

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

@ -17,11 +17,13 @@
#ifndef GSL_POINTERS_H
#define GSL_POINTERS_H
#include <gsl/gsl_assert>
#include <gsl/gsl_assert> // for Ensures, Expects
#include <iosfwd>
#include <memory>
#include <type_traits>
#include <algorithm> // for forward
#include <iosfwd> // for ptrdiff_t, nullptr_t, ostream, size_t
#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
#pragma push_macro("constexpr")
@ -80,6 +82,7 @@ public:
{
}
not_null(not_null&& other) = default;
not_null(const not_null& other) = default;
not_null& operator=(const not_null& other) = default;

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

@ -17,16 +17,17 @@
#ifndef GSL_SPAN_H
#define GSL_SPAN_H
#include <gsl/gsl_assert>
#include <gsl/gsl_byte>
#include <gsl/gsl_util>
#include <gsl/gsl_assert> // for Expects
#include <gsl/gsl_byte> // for byte
#include <gsl/gsl_util> // for narrow_cast, narrow
#include <array>
#include <iterator>
#include <algorithm> // for lexicographical_compare
#include <array> // for array
#include <cstddef> // for ptrdiff_t, size_t, nullptr_t
#include <iterator> // for reverse_iterator, distance, random_access_...
#include <limits>
#include <memory>
#include <stdexcept>
#include <type_traits>
#include <type_traits> // for enable_if_t, declval, is_convertible, inte...
#include <utility>
#ifdef _MSC_VER
@ -44,15 +45,20 @@
#if _MSC_VER < 1910
#pragma push_macro("constexpr")
#define constexpr /*constexpr*/
#define GSL_USE_STATIC_CONSTEXPR_WORKAROUND
#endif // _MSC_VER < 1910
#else // _MSC_VER
// See if we have enough C++17 power to use a static constexpr data member
// without needing an out-of-line definition
#if !(defined(__cplusplus) && (__cplusplus >= 201703L))
#define GSL_USE_STATIC_CONSTEXPR_WORKAROUND
#endif // !(defined(__cplusplus) && (__cplusplus >= 201703L))
#endif // _MSC_VER
#ifdef GSL_THROW_ON_CONTRACT_VIOLATION
#define GSL_NOEXCEPT /*noexcept*/
#else
#define GSL_NOEXCEPT noexcept
#endif // GSL_THROW_ON_CONTRACT_VIOLATION
namespace gsl
{
@ -115,6 +121,12 @@ namespace details
using element_type_ = typename Span::element_type;
public:
#ifdef _MSC_VER
// Tell Microsoft standard library that span_iterators are checked.
using _Unchecked_type = typename Span::pointer;
#endif
using iterator_category = std::random_access_iterator_tag;
using value_type = std::remove_cv_t<element_type_>;
using difference_type = typename Span::index_type;
@ -124,11 +136,9 @@ namespace details
span_iterator() = default;
constexpr span_iterator(const Span* span, typename Span::index_type index) GSL_NOEXCEPT
: span_(span), index_(index)
{
Expects(span == nullptr || (0 <= index_ && index <= span_->length()));
}
constexpr span_iterator(const Span* span, typename Span::index_type idx) GSL_NOEXCEPT
: span_(span), index_(idx)
{}
friend span_iterator<Span, true>;
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_);
}
constexpr pointer operator->() const GSL_NOEXCEPT
constexpr pointer operator->() const
{
Expects(index_ != span_->length());
Expects(index_ != span_->size());
return span_->data() + index_;
}
constexpr span_iterator& operator++() GSL_NOEXCEPT
constexpr span_iterator& operator++()
{
Expects(0 <= index_ && index_ != span_->length());
Expects(0 <= index_ && index_ != span_->size());
++index_;
return *this;
}
constexpr span_iterator operator++(int) GSL_NOEXCEPT
constexpr span_iterator operator++(int)
{
auto ret = *this;
++(*this);
return ret;
}
constexpr span_iterator& operator--() GSL_NOEXCEPT
constexpr span_iterator& operator--()
{
Expects(index_ != 0 && index_ <= span_->length());
Expects(index_ != 0 && index_ <= span_->size());
--index_;
return *this;
}
constexpr span_iterator operator--(int) GSL_NOEXCEPT
constexpr span_iterator operator--(int)
{
auto ret = *this;
--(*this);
return ret;
}
constexpr span_iterator operator+(difference_type n) const GSL_NOEXCEPT
constexpr span_iterator operator+(difference_type n) const
{
auto ret = *this;
return ret += n;
}
constexpr span_iterator& operator+=(difference_type n) GSL_NOEXCEPT
constexpr span_iterator& operator+=(difference_type n)
{
Expects((index_ + n) >= 0 && (index_ + n) <= span_->length());
Expects((index_ + n) >= 0 && (index_ + n) <= span_->size());
index_ += n;
return *this;
}
constexpr span_iterator operator-(difference_type n) const GSL_NOEXCEPT
constexpr span_iterator operator-(difference_type n) const
{
auto ret = *this;
return ret -= n;
}
constexpr span_iterator& operator-=(difference_type n) GSL_NOEXCEPT { return *this += -n; }
constexpr span_iterator& operator-=(difference_type n) { return *this += -n; }
constexpr difference_type operator-(const span_iterator& rhs) const GSL_NOEXCEPT
constexpr difference_type operator-(span_iterator rhs) const
{
Expects(span_ == rhs.span_);
return index_ - rhs.index_;
}
constexpr reference operator[](difference_type n) const GSL_NOEXCEPT
constexpr reference operator[](difference_type n) const
{
return *(*this + n);
}
constexpr friend bool operator==(const span_iterator& lhs,
const span_iterator& rhs) GSL_NOEXCEPT
constexpr friend bool operator==(span_iterator lhs,
span_iterator rhs) GSL_NOEXCEPT
{
return lhs.span_ == rhs.span_ && lhs.index_ == rhs.index_;
}
constexpr friend bool operator!=(const span_iterator& lhs,
const span_iterator& rhs) GSL_NOEXCEPT
constexpr friend bool operator!=(span_iterator lhs,
span_iterator rhs) GSL_NOEXCEPT
{
return !(lhs == rhs);
}
constexpr friend bool operator<(const span_iterator& lhs,
const span_iterator& rhs) GSL_NOEXCEPT
constexpr friend bool operator<(span_iterator lhs,
span_iterator rhs) GSL_NOEXCEPT
{
Expects(lhs.span_ == rhs.span_);
return lhs.index_ < rhs.index_;
}
constexpr friend bool operator<=(const span_iterator& lhs,
const span_iterator& rhs) GSL_NOEXCEPT
constexpr friend bool operator<=(span_iterator lhs,
span_iterator rhs) GSL_NOEXCEPT
{
return !(rhs < lhs);
}
constexpr friend bool operator>(const span_iterator& lhs,
const span_iterator& rhs) GSL_NOEXCEPT
constexpr friend bool operator>(span_iterator lhs,
span_iterator rhs) GSL_NOEXCEPT
{
return rhs < lhs;
}
constexpr friend bool operator>=(const span_iterator& lhs,
const span_iterator& rhs) GSL_NOEXCEPT
constexpr friend bool operator>=(span_iterator lhs,
span_iterator rhs) GSL_NOEXCEPT
{
return !(rhs > lhs);
}
@ -252,17 +261,17 @@ namespace details
};
template <class Span, bool IsConst>
inline constexpr span_iterator<Span, IsConst>
constexpr span_iterator<Span, IsConst>
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;
}
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,
const span_iterator<Span, IsConst>& rhs) GSL_NOEXCEPT
span_iterator<Span, IsConst> rhs)
{
return rhs - n;
}
@ -308,6 +317,12 @@ namespace details
private:
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
// [span], class template span
@ -329,7 +344,11 @@ public:
using size_type = index_type;
constexpr static const index_type extent = Extent;
#if defined(GSL_USE_STATIC_CONSTEXPR_WORKAROUND)
static constexpr const index_type extent { Extent };
#else
static constexpr index_type extent { Extent };
#endif
// [span.cons], span constructors, copy, assignment, and destructor
template <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 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
// on Container to be a contiguous sequence container.
template <class Container,
@ -403,7 +407,6 @@ public:
}
constexpr span(const span& other) GSL_NOEXCEPT = default;
constexpr span(span&& other) GSL_NOEXCEPT = default;
template <
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;
constexpr span& operator=(const span& other) GSL_NOEXCEPT = default;
constexpr span& operator=(span&& other) GSL_NOEXCEPT = default;
// [span.sub], span subviews
template <std::ptrdiff_t Count>
constexpr span<element_type, Count> first() const
@ -446,7 +437,7 @@ public:
}
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) &&
(Count == dynamic_extent || (Count >= 0 && Offset + Count <= size())));
@ -473,9 +464,7 @@ public:
// [span.obs], span observers
constexpr index_type length() const GSL_NOEXCEPT { return size(); }
constexpr index_type size() const GSL_NOEXCEPT { return storage_.size(); }
constexpr index_type length_bytes() const GSL_NOEXCEPT { return size_bytes(); }
constexpr index_type size_bytes() const GSL_NOEXCEPT
{
return size() * narrow_cast<index_type>(sizeof(element_type));
@ -494,17 +483,17 @@ public:
constexpr pointer data() const GSL_NOEXCEPT { return storage_.data(); }
// [span.iter], span iterator support
iterator begin() const GSL_NOEXCEPT { return {this, 0}; }
iterator end() const GSL_NOEXCEPT { return {this, length()}; }
constexpr iterator begin() const GSL_NOEXCEPT { return {this, 0}; }
constexpr iterator end() const GSL_NOEXCEPT { return {this, size()}; }
const_iterator cbegin() const GSL_NOEXCEPT { return {this, 0}; }
const_iterator cend() const GSL_NOEXCEPT { return {this, length()}; }
constexpr const_iterator cbegin() const GSL_NOEXCEPT { return {this, 0}; }
constexpr const_iterator cend() const GSL_NOEXCEPT { return {this, size()}; }
reverse_iterator rbegin() const GSL_NOEXCEPT { return reverse_iterator{end()}; }
reverse_iterator rend() const GSL_NOEXCEPT { return reverse_iterator{begin()}; }
constexpr reverse_iterator rbegin() const GSL_NOEXCEPT { return reverse_iterator{end()}; }
constexpr reverse_iterator rend() const GSL_NOEXCEPT { return reverse_iterator{begin()}; }
const_reverse_iterator crbegin() const GSL_NOEXCEPT { return const_reverse_iterator{cend()}; }
const_reverse_iterator crend() const GSL_NOEXCEPT { return const_reverse_iterator{cbegin()}; }
constexpr const_reverse_iterator crbegin() const GSL_NOEXCEPT { return const_reverse_iterator{cend()}; }
constexpr const_reverse_iterator crend() const GSL_NOEXCEPT { return const_reverse_iterator{cbegin()}; }
private:
// this implementation detail class lets us take advantage of the
@ -540,7 +529,7 @@ private:
template <std::ptrdiff_t CallerExtent>
span<element_type, dynamic_extent> make_subspan(index_type offset,
index_type count,
subspan_selector<CallerExtent>) const GSL_NOEXCEPT
subspan_selector<CallerExtent>) const
{
span<element_type, dynamic_extent> tmp(*this);
return tmp.subspan(offset, count);
@ -548,7 +537,7 @@ private:
span<element_type, dynamic_extent> make_subspan(index_type offset,
index_type count,
subspan_selector<dynamic_extent>) const GSL_NOEXCEPT
subspan_selector<dynamic_extent>) const
{
Expects(offset >= 0 && size() - offset >= 0);
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
template <class ElementType, std::ptrdiff_t FirstExtent, std::ptrdiff_t SecondExtent>
inline constexpr bool operator==(const span<ElementType, FirstExtent>& l,
const span<ElementType, SecondExtent>& r)
constexpr bool operator==(span<ElementType, FirstExtent> l,
span<ElementType, SecondExtent> r)
{
return std::equal(l.begin(), l.end(), r.begin(), r.end());
}
template <class ElementType, std::ptrdiff_t Extent>
inline constexpr bool operator!=(const span<ElementType, Extent>& l,
const span<ElementType, Extent>& r)
constexpr bool operator!=(span<ElementType, Extent> l,
span<ElementType, Extent> r)
{
return !(l == r);
}
template <class ElementType, std::ptrdiff_t Extent>
inline constexpr bool operator<(const span<ElementType, Extent>& l,
const span<ElementType, Extent>& r)
constexpr bool operator<(span<ElementType, Extent> l,
span<ElementType, Extent> r)
{
return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end());
}
template <class ElementType, std::ptrdiff_t Extent>
inline constexpr bool operator<=(const span<ElementType, Extent>& l,
const span<ElementType, Extent>& r)
constexpr bool operator<=(span<ElementType, Extent> l,
span<ElementType, Extent> r)
{
return !(l > r);
}
template <class ElementType, std::ptrdiff_t Extent>
inline constexpr bool operator>(const span<ElementType, Extent>& l,
const span<ElementType, Extent>& r)
constexpr bool operator>(span<ElementType, Extent> l,
span<ElementType, Extent> r)
{
return r < l;
}
template <class ElementType, std::ptrdiff_t Extent>
inline constexpr bool operator>=(const span<ElementType, Extent>& l,
const span<ElementType, Extent>& r)
constexpr bool operator>=(span<ElementType, Extent> l,
span<ElementType, Extent> r)
{
return !(l < r);
}
@ -648,53 +642,53 @@ as_writeable_bytes(span<ElementType, Extent> s) GSL_NOEXCEPT
// make_span() - Utility functions for creating spans
//
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
// Specialization of gsl::at for span
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
return s[index];
return s[i];
}
} // namespace gsl

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

@ -17,13 +17,17 @@
#ifndef GSL_STRING_SPAN_H
#define GSL_STRING_SPAN_H
#include <gsl/gsl_assert>
#include <gsl/gsl_util>
#include <gsl/span>
#include <gsl/gsl_assert> // for Ensures, Expects
#include <gsl/gsl_util> // for narrow_cast
#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 <string>
#include <string> // for basic_string, allocator, char_traits
#include <type_traits> // for declval, is_convertible, enable_if_t, add_...
#ifdef _MSC_VER
#pragma warning(push)
@ -94,7 +98,7 @@ namespace details
{
if (str == nullptr || n <= 0) return 0;
span<const CharT> str_span{str, n};
const span<const CharT> str_span{str, n};
std::ptrdiff_t len = 0;
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.
//
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);
}
@ -141,7 +145,7 @@ template <class Cont>
span<typename std::remove_pointer<typename Cont::pointer>::type, dynamic_extent>
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>
@ -190,18 +194,9 @@ public:
// copy
constexpr basic_string_span(const basic_string_span& other) GSL_NOEXCEPT = default;
// move
constexpr basic_string_span(basic_string_span&& other) GSL_NOEXCEPT = default;
// assign
constexpr basic_string_span& operator=(const basic_string_span& other) GSL_NOEXCEPT = default;
// move assign
constexpr basic_string_span& operator=(basic_string_span&& other) GSL_NOEXCEPT = default;
// from nullptr
constexpr basic_string_span(std::nullptr_t ptr) GSL_NOEXCEPT : span_(ptr) {}
constexpr basic_string_span(pointer ptr, index_type length) : span_(ptr, length) {}
constexpr basic_string_span(pointer firstElem, pointer lastElem) : span_(firstElem, lastElem) {}

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 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;

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 <vector>
#include <array> // for array
#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;

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 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 <iostream>
#include <list>
#include <map>
#include <memory>
#include <string>
#include <vector>
#include <gsl/gsl_byte> // for to_byte, to_integer, byte, operator&, ope...
using namespace std;
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 <list>
#include <map>
#include <memory>
#include <string>
#include <vector>
#include <algorithm> // for fill, for_each
#include <array> // for array
#include <iostream> // for ptrdiff_t, size_t
#include <iterator> // for reverse_iterator, begin, end, operator!=
#include <numeric> // for iota
#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 gsl;
@ -1235,7 +1243,7 @@ TEST_CASE("empty_spans")
{
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.begin()[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 = {};
CHECK(empty_av.bounds().index_bounds() == index<1>{0});
CHECK(empty_av.bounds().index_bounds() == multi_span_index<1>{0});
CHECK_THROWS_AS(empty_av[0], fail_fast);
CHECK_THROWS_AS(empty_av.begin()[0], fail_fast);
CHECK_THROWS_AS(empty_av.cbegin()[0], fail_fast);
@ -1269,13 +1277,13 @@ TEST_CASE("index_constructor")
multi_span<int, dynamic_range> av(arr, 8);
ptrdiff_t a[1] = {0};
index<1> i = a;
multi_span_index<1> i = a;
CHECK(av[i] == 4);
auto av2 = as_multi_span(av, dim<4>(), dim(2));
ptrdiff_t a2[2] = {0, 1};
index<2> i2 = a2;
multi_span_index<2> i2 = a2;
CHECK(av2[i2] == 0);
CHECK(av2[0][i] == 4);
@ -1287,70 +1295,70 @@ TEST_CASE("index_constructors")
{
{
// components of the same type
index<3> i1(0, 1, 2);
multi_span_index<3> i1(0, 1, 2);
CHECK(i1[0] == 0);
// components of different types
std::size_t c0 = 0;
std::size_t c1 = 1;
index<3> i2(c0, c1, 2);
multi_span_index<3> i2(c0, c1, 2);
CHECK(i2[0] == 0);
// from array
index<3> i3 = {0, 1, 2};
multi_span_index<3> i3 = {0, 1, 2};
CHECK(i3[0] == 0);
// from other index of the same size type
index<3> i4 = i3;
multi_span_index<3> i4 = i3;
CHECK(i4[0] == 0);
// default
index<3> i7;
multi_span_index<3> i7;
CHECK(i7[0] == 0);
// default
index<3> i9 = {};
multi_span_index<3> i9 = {};
CHECK(i9[0] == 0);
}
{
// components of the same type
index<1> i1(0);
multi_span_index<1> i1(0);
CHECK(i1[0] == 0);
// components of different types
std::size_t c0 = 0;
index<1> i2(c0);
multi_span_index<1> i2(c0);
CHECK(i2[0] == 0);
// from array
index<1> i3 = {0};
multi_span_index<1> i3 = {0};
CHECK(i3[0] == 0);
// from int
index<1> i4 = 0;
multi_span_index<1> i4 = 0;
CHECK(i4[0] == 0);
// from other index of the same size type
index<1> i5 = i3;
multi_span_index<1> i5 = i3;
CHECK(i5[0] == 0);
// default
index<1> i8;
multi_span_index<1> i8;
CHECK(i8[0] == 0);
// default
index<1> i9 = {};
multi_span_index<1> i9 = {};
CHECK(i9[0] == 0);
}
#ifdef CONFIRM_COMPILATION_ERRORS
{
index<3> i1(0, 1);
index<3> i2(0, 1, 2, 3);
index<3> i3 = {0};
index<3> i4 = {0, 1, 2, 3};
index<1> i5 = {0, 1};
multi_span_index<3> i1(0, 1);
multi_span_index<3> i2(0, 1, 2, 3);
multi_span_index<3> i3 = {0};
multi_span_index<3> i4 = {0, 1, 2, 3};
multi_span_index<1> i5 = {0, 1};
}
#endif
}
@ -1359,15 +1367,15 @@ TEST_CASE("index_operations")
{
ptrdiff_t a[3] = {0, 1, 2};
ptrdiff_t b[3] = {3, 4, 5};
index<3> i = a;
index<3> j = b;
multi_span_index<3> i = a;
multi_span_index<3> j = b;
CHECK(i[0] == 0);
CHECK(i[1] == 1);
CHECK(i[2] == 2);
{
index<3> k = i + j;
multi_span_index<3> k = i + j;
CHECK(i[0] == 0);
CHECK(i[1] == 1);
@ -1378,7 +1386,7 @@ TEST_CASE("index_operations")
}
{
index<3> k = i * 3;
multi_span_index<3> k = i * 3;
CHECK(i[0] == 0);
CHECK(i[1] == 1);
@ -1389,7 +1397,7 @@ TEST_CASE("index_operations")
}
{
index<3> k = 3 * i;
multi_span_index<3> k = 3 * i;
CHECK(i[0] == 0);
CHECK(i[1] == 1);
@ -1400,7 +1408,7 @@ TEST_CASE("index_operations")
}
{
index<2> k = details::shift_left(i);
multi_span_index<2> k = details::shift_left(i);
CHECK(i[0] == 0);
CHECK(i[1] == 1);
@ -1423,7 +1431,7 @@ void iterate_second_column(multi_span<int, dynamic_range, dynamic_range> av)
}
for (auto i = 0; i < section.size(); ++i) {
auto idx = index<2>{i, 0}; // avoid braces inside the CHECK macro
auto idx = multi_span_index<2>{i, 0}; // avoid braces inside the CHECK macro
CHECK(section[idx] == av[i][1]);
}
@ -1431,7 +1439,7 @@ void iterate_second_column(multi_span<int, dynamic_range, dynamic_range> av)
CHECK(section.bounds().index_bounds()[1] == 1);
for (auto i = 0; i < section.bounds().index_bounds()[0]; ++i) {
for (auto j = 0; j < section.bounds().index_bounds()[1]; ++j) {
auto idx = index<2>{i, j}; // avoid braces inside the CHECK macro
auto idx = multi_span_index<2>{i, j}; // avoid braces inside the CHECK macro
CHECK(section[idx] == av[i][1]);
}
}

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 <string>
#include <vector>
#include <algorithm> // for addressof
#include <memory> // for shared_ptr, make_shared, operator<, opera...
#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;
@ -127,6 +134,11 @@ TEST_CASE("TestNotNullConstructors")
not_null<std::shared_ptr<int>> x(
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>
@ -315,3 +327,5 @@ TEST_CASE("TestNotNullCustomPtrComparison")
CHECK((NotNull1(p1) >= NotNull2(p2)) == (p1 >= p2));
CHECK((NotNull2(p2) >= NotNull1(p1)) == (p2 >= p1));
}
static_assert(std::is_nothrow_move_constructible<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 <functional>
#include <memory>
#include <gsl/pointers> // for owner
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 <list>
#include <map>
#include <memory>
#include <regex>
#include <string>
#include <vector>
#include <array> // for array
#include <iostream> // for ptrdiff_t
#include <iterator> // for reverse_iterator, operator-, operator==
#include <memory> // for unique_ptr, shared_ptr, make_unique, allo...
#include <regex> // for match_results, sub_match, match_results<>...
#include <stddef.h> // for ptrdiff_t
#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 gsl;
@ -43,33 +51,33 @@ TEST_CASE("default_constructor")
{
{
span<int> s;
CHECK((s.length() == 0 && s.data() == nullptr));
CHECK((s.size() == 0 && s.data() == nullptr));
span<const int> cs;
CHECK((cs.length() == 0 && cs.data() == nullptr));
CHECK((cs.size() == 0 && cs.data() == nullptr));
}
{
span<int, 0> s;
CHECK((s.length() == 0 && s.data() == nullptr));
CHECK((s.size() == 0 && s.data() == nullptr));
span<const int, 0> cs;
CHECK((cs.length() == 0 && cs.data() == nullptr));
CHECK((cs.size() == 0 && cs.data() == nullptr));
}
{
#ifdef CONFIRM_COMPILATION_ERRORS
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
}
{
span<int> s{};
CHECK((s.length() == 0 && s.data() == nullptr));
CHECK((s.size() == 0 && s.data() == nullptr));
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")
{
{
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")
TEST_CASE("from_nullptr_size_constructor")
{
{
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)};
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)};
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)};
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)};
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)};
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 };
CHECK(s.length() == i);
CHECK(s.size() == i);
CHECK(s.data() == &arr[0]);
CHECK(s.empty() == (i == 0));
for (int j = 0; j < i; ++j)
@ -199,7 +165,7 @@ TEST_CASE("from_pointer_length_constructor")
}
{
span<int> s = { &arr[i], 4-i };
CHECK(s.length() == 4-i);
CHECK(s.size() == 4-i);
CHECK(s.data() == &arr[i]);
CHECK(s.empty() == (4-i == 0));
for (int j = 0; j < 4-i; ++j)
@ -214,14 +180,14 @@ TEST_CASE("from_pointer_length_constructor")
{
span<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));
}
{
int* p = nullptr;
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);
CHECK((s.length() == 2 && s.data() == &arr[0]));
CHECK((s.size() == 2 && s.data() == &arr[0]));
CHECK((s[0] == 1 && s[1] == 2));
}
{
int* p = nullptr;
auto s = make_span(p, static_cast<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]};
CHECK((s.length() == 2 && s.data() == &arr[0]));
CHECK((s.size() == 2 && s.data() == &arr[0]));
CHECK((s[0] == 1 && s[1] == 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));
}
{
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]};
CHECK((s.length() == 0 && s.data() == &arr[0]));
CHECK((s.size() == 0 && s.data() == &arr[0]));
}
// this will fail the std::distance() precondition, which asserts on MSVC debug builds
@ -291,13 +257,13 @@ TEST_CASE("from_pointer_pointer_constructor")
{
int* p = nullptr;
span<int> s{p, p};
CHECK((s.length() == 0 && s.data() == nullptr));
CHECK((s.size() == 0 && s.data() == nullptr));
}
{
int* p = nullptr;
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
@ -309,19 +275,19 @@ TEST_CASE("from_pointer_pointer_constructor")
{
auto s = make_span(&arr[0], &arr[2]);
CHECK((s.length() == 2 && s.data() == &arr[0]));
CHECK((s.size() == 2 && s.data() == &arr[0]));
CHECK((s[0] == 1 && s[1] == 2));
}
{
auto s = make_span(&arr[0], &arr[0]);
CHECK((s.length() == 0 && s.data() == &arr[0]));
CHECK((s.size() == 0 && s.data() == &arr[0]));
}
{
int* p = nullptr;
auto s = make_span(p, p);
CHECK((s.length() == 0 && s.data() == nullptr));
CHECK((s.size() == 0 && s.data() == nullptr));
}
}
@ -331,12 +297,12 @@ TEST_CASE("from_array_constructor")
{
span<int> s{arr};
CHECK((s.length() == 5 && s.data() == &arr[0]));
CHECK((s.size() == 5 && s.data() == &arr[0]));
}
{
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};
@ -348,18 +314,18 @@ TEST_CASE("from_array_constructor")
{
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};
CHECK((s.length() == 6 && s.data() == &arr2d[0][0]));
CHECK((s.size() == 6 && s.data() == &arr2d[0][0]));
CHECK((s[0] == 1 && s[5] == 6));
}
{
span<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
{
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};
@ -376,13 +342,13 @@ TEST_CASE("from_array_constructor")
#ifdef CONFIRM_COMPILATION_ERRORS
{
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));
}
{
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};
CHECK((s.length() == 12 && s.data() == &arr3d[0][0][0]));
CHECK((s.size() == 12 && s.data() == &arr3d[0][0][0]));
CHECK((s[0] == 1 && s[5] == 6));
}
#endif
{
span<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);
CHECK((s.length() == 5 && s.data() == &arr[0]));
CHECK((s.size() == 5 && s.data() == &arr[0]));
}
{
auto s = make_span(&(arr2d[0]), 1);
CHECK((s.length() == 1 && s.data() == &arr2d[0]));
CHECK((s.size() == 1 && s.data() == &arr2d[0]));
}
{
auto s = make_span(&arr3d[0], 1);
CHECK((s.length() == 1 && s.data() == &arr3d[0]));
CHECK((s.size() == 1 && s.data() == &arr3d[0]));
}
}
@ -422,12 +388,12 @@ TEST_CASE("from_dynamic_array_constructor")
{
span<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);
CHECK((s.length() == 10 && s.data() == &arr[0][0][0]));
CHECK((s.size() == 10 && s.data() == &arr[0][0][0]));
}
delete[] arr;
@ -578,104 +544,6 @@ TEST_CASE("from_std_array_const_constructor")
}
}
TEST_CASE("from_unique_pointer_construction")
{
{
auto ptr = std::make_unique<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")
{
std::vector<int> v = {1, 2, 3};
@ -813,17 +681,17 @@ TEST_CASE("copy_move_and_assignment")
int arr[] = {3, 4, 5};
span<const int> s2 = arr;
CHECK((s2.length() == 3 && s2.data() == &arr[0]));
CHECK((s2.size() == 3 && s2.data() == &arr[0]));
s2 = s1;
CHECK(s2.empty());
auto get_temp_span = [&]() -> span<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());
s1 = get_temp_span();
CHECK((s1.length() == 2 && s1.data() == &arr[1]));
CHECK((s1.size() == 2 && s1.data() == &arr[1]));
}
TEST_CASE("first")
@ -832,35 +700,35 @@ TEST_CASE("first")
{
span<int, 5> av = arr;
CHECK(av.first<2>().length() == 2);
CHECK(av.first(2).length() == 2);
CHECK(av.first<2>().size() == 2);
CHECK(av.first(2).size() == 2);
}
{
span<int, 5> av = arr;
CHECK(av.first<0>().length() == 0);
CHECK(av.first(0).length() == 0);
CHECK(av.first<0>().size() == 0);
CHECK(av.first(0).size() == 0);
}
{
span<int, 5> av = arr;
CHECK(av.first<5>().length() == 5);
CHECK(av.first(5).length() == 5);
CHECK(av.first<5>().size() == 5);
CHECK(av.first(5).size() == 5);
}
{
span<int, 5> av = arr;
#ifdef CONFIRM_COMPILATION_ERRORS
CHECK(av.first<6>().length() == 6);
CHECK(av.first<-1>().length() == -1);
CHECK(av.first<6>().size() == 6);
CHECK(av.first<-1>().size() == -1);
#endif
CHECK_THROWS_AS(av.first(6).length(), fail_fast);
CHECK_THROWS_AS(av.first(6).size(), fail_fast);
}
{
span<int> av;
CHECK(av.first<0>().length() == 0);
CHECK(av.first(0).length() == 0);
CHECK(av.first<0>().size() == 0);
CHECK(av.first(0).size() == 0);
}
}
@ -870,34 +738,34 @@ TEST_CASE("last")
{
span<int, 5> av = arr;
CHECK(av.last<2>().length() == 2);
CHECK(av.last(2).length() == 2);
CHECK(av.last<2>().size() == 2);
CHECK(av.last(2).size() == 2);
}
{
span<int, 5> av = arr;
CHECK(av.last<0>().length() == 0);
CHECK(av.last(0).length() == 0);
CHECK(av.last<0>().size() == 0);
CHECK(av.last(0).size() == 0);
}
{
span<int, 5> av = arr;
CHECK(av.last<5>().length() == 5);
CHECK(av.last(5).length() == 5);
CHECK(av.last<5>().size() == 5);
CHECK(av.last(5).size() == 5);
}
{
span<int, 5> av = arr;
#ifdef CONFIRM_COMPILATION_ERRORS
CHECK(av.last<6>().length() == 6);
CHECK(av.last<6>().size() == 6);
#endif
CHECK_THROWS_AS(av.last(6).length(), fail_fast);
CHECK_THROWS_AS(av.last(6).size(), fail_fast);
}
{
span<int> av;
CHECK(av.last<0>().length() == 0);
CHECK(av.last(0).length() == 0);
CHECK(av.last<0>().size() == 0);
CHECK(av.last(0).size() == 0);
}
}
@ -907,64 +775,76 @@ TEST_CASE("subspan")
{
span<int, 5> av = arr;
CHECK((av.subspan<2, 2>().length() == 2));
CHECK(av.subspan(2, 2).length() == 2);
CHECK(av.subspan(2, 3).length() == 3);
CHECK((av.subspan<2, 2>().size() == 2));
CHECK(decltype(av.subspan<2, 2>())::extent == 2);
CHECK(av.subspan(2, 2).size() == 2);
CHECK(av.subspan(2, 3).size() == 3);
}
{
span<int, 5> av = arr;
CHECK((av.subspan<0, 0>().length() == 0));
CHECK(av.subspan(0, 0).length() == 0);
CHECK((av.subspan<0, 0>().size() == 0));
CHECK(decltype(av.subspan<0,0>())::extent == 0);
CHECK(av.subspan(0, 0).size() == 0);
}
{
span<int, 5> av = arr;
CHECK((av.subspan<0, 5>().length() == 5));
CHECK(av.subspan(0, 5).length() == 5);
CHECK_THROWS_AS(av.subspan(0, 6).length(), fail_fast);
CHECK_THROWS_AS(av.subspan(1, 5).length(), fail_fast);
CHECK((av.subspan<0, 5>().size() == 5));
CHECK(decltype(av.subspan<0, 5>())::extent == 5);
CHECK(av.subspan(0, 5).size() == 5);
CHECK_THROWS_AS(av.subspan(0, 6).size(), fail_fast);
CHECK_THROWS_AS(av.subspan(1, 5).size(), fail_fast);
}
{
span<int, 5> av = arr;
CHECK((av.subspan<4, 0>().length() == 0));
CHECK(av.subspan(4, 0).length() == 0);
CHECK(av.subspan(5, 0).length() == 0);
CHECK_THROWS_AS(av.subspan(6, 0).length(), fail_fast);
CHECK((av.subspan<4, 0>().size() == 0));
CHECK(decltype(av.subspan<4, 0>())::extent == 0);
CHECK(av.subspan(4, 0).size() == 0);
CHECK(av.subspan(5, 0).size() == 0);
CHECK_THROWS_AS(av.subspan(6, 0).size(), fail_fast);
}
{
span<int, 5> av = arr;
CHECK((av.subspan<1>().size() == 4));
CHECK(decltype(av.subspan<1>())::extent == 4);
}
{
span<int> av;
CHECK((av.subspan<0, 0>().length() == 0));
CHECK(av.subspan(0, 0).length() == 0);
CHECK_THROWS_AS((av.subspan<1, 0>().length()), fail_fast);
CHECK((av.subspan<0, 0>().size() == 0));
CHECK((decltype(av.subspan<0, 0>())::extent == 0));
CHECK(av.subspan(0, 0).size() == 0);
CHECK_THROWS_AS((av.subspan<1, 0>().size()), fail_fast);
}
{
span<int> av;
CHECK(av.subspan(0).length() == 0);
CHECK_THROWS_AS(av.subspan(1).length(), fail_fast);
CHECK(av.subspan(0).size() == 0);
CHECK_THROWS_AS(av.subspan(1).size(), fail_fast);
}
{
span<int> av = arr;
CHECK(av.subspan(0).length() == 5);
CHECK(av.subspan(1).length() == 4);
CHECK(av.subspan(4).length() == 1);
CHECK(av.subspan(5).length() == 0);
CHECK_THROWS_AS(av.subspan(6).length(), fail_fast);
CHECK(av.subspan(0).size() == 5);
CHECK(av.subspan(1).size() == 4);
CHECK(av.subspan(4).size() == 1);
CHECK(av.subspan(5).size() == 0);
CHECK_THROWS_AS(av.subspan(6).size(), fail_fast);
const auto av2 = av.subspan(1);
for (int i = 0; i < 4; ++i) CHECK(av2[i] == i + 2);
}
{
span<int, 5> av = arr;
CHECK(av.subspan(0).length() == 5);
CHECK(av.subspan(1).length() == 4);
CHECK(av.subspan(4).length() == 1);
CHECK(av.subspan(5).length() == 0);
CHECK_THROWS_AS(av.subspan(6).length(), fail_fast);
CHECK(av.subspan(0).size() == 5);
CHECK(av.subspan(1).size() == 4);
CHECK(av.subspan(4).size() == 1);
CHECK(av.subspan(5).size() == 0);
CHECK_THROWS_AS(av.subspan(6).size(), fail_fast);
const auto av2 = av.subspan(1);
for (int i = 0; i < 4; ++i) CHECK(av2[i] == i + 2);
}
@ -1282,8 +1162,8 @@ TEST_CASE("crbegin_crend")
TEST_CASE("comparison_operators")
{
{
span<int> s1 = nullptr;
span<int> s2 = nullptr;
span<int> s1;
span<int> s2;
CHECK(s1 == s2);
CHECK(!(s1 != s2));
CHECK(!(s1 < s2));
@ -1320,7 +1200,7 @@ TEST_CASE("comparison_operators")
{
int arr[] = {2, 1}; // bigger
span<int> s1 = nullptr;
span<int> s1;
span<int> s2 = arr;
CHECK(s1 != s2);
@ -1405,17 +1285,17 @@ TEST_CASE("as_bytes")
{
const span<const int> s = a;
CHECK(s.length() == 4);
CHECK(s.size() == 4);
const span<const byte> bs = as_bytes(s);
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;
const auto bs = as_bytes(s);
CHECK(bs.length() == s.length());
CHECK(bs.length() == 0);
CHECK(bs.size() == s.size());
CHECK(bs.size() == 0);
CHECK(bs.size_bytes() == 0);
CHECK(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data()));
CHECK(bs.data() == nullptr);
@ -1425,7 +1305,7 @@ TEST_CASE("as_bytes")
span<int> s = a;
const auto bs = as_bytes(s);
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
// you should not be able to get writeable bytes for const objects
span<const int> s = a;
CHECK(s.length() == 4);
CHECK(s.size() == 4);
span<const byte> bs = as_writeable_bytes(s);
CHECK(static_cast<void*>(bs.data()) == static_cast<void*>(s.data()));
CHECK(bs.length() == s.length_bytes());
CHECK(bs.size() == s.size_bytes());
#endif
}
{
span<int> s;
const auto bs = as_writeable_bytes(s);
CHECK(bs.length() == s.length());
CHECK(bs.length() == 0);
CHECK(bs.size() == s.size());
CHECK(bs.size() == 0);
CHECK(bs.size_bytes() == 0);
CHECK(static_cast<void*>(bs.data()) == static_cast<void*>(s.data()));
CHECK(bs.data() == nullptr);
@ -1458,7 +1338,7 @@ TEST_CASE("as_writeable_bytes")
span<int> s = a;
const auto bs = as_writeable_bytes(s);
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
span<int, 4> s4 = arr;
CHECK(s4.length() == 4);
CHECK(s4.size() == 4);
// converting to dynamic_range is always ok
{
span<int> s = s4;
CHECK(s.length() == s4.length());
CHECK(s.size() == s4.size());
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 <list>
#include <map>
#include <memory>
#include <string>
#include <vector>
#include <iostream> // for size_t
#include <iterator> // for begin, end
#include <numeric> // for iota
#include <type_traits> // for integral_constant<>::value, is_convertible
#include <vector> // for vector
namespace gsl {
struct fail_fast;
} // namespace gsl
using namespace std;
using namespace gsl;
@ -43,8 +48,8 @@ TEST_CASE("span_section_test")
int a[30][4][5];
const auto av = as_multi_span(a);
const auto sub = av.section({15, 0, 0}, gsl::index<3>{2, 2, 2});
const auto subsub = sub.section({1, 0, 0}, gsl::index<3>{1, 1, 1});
const auto sub = av.section({15, 0, 0}, gsl::multi_span_index<3>{2, 2, 2});
const auto subsub = sub.section({1, 0, 0}, gsl::multi_span_index<3>{1, 1, 1});
(void) subsub;
}
@ -74,18 +79,18 @@ TEST_CASE("strided_span_constructors")
const int carr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
strided_span<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[0] == 1 && sav1[8] == 9));
strided_span<const int, 1> sav2{carr, {{4}, {2}}}; // const T -> const T
CHECK(sav2.bounds().index_bounds() == index<1>{4});
CHECK(sav2.bounds().strides() == index<1>{2});
CHECK(sav2.bounds().index_bounds() == multi_span_index<1>{4});
CHECK(sav2.bounds().strides() == multi_span_index<1>{2});
CHECK((sav2[0] == 1 && sav2[3] == 7));
strided_span<int, 2> sav3{arr, {{2, 2}, {6, 2}}}; // T -> const T
CHECK((sav3.bounds().index_bounds() == index<2>{2, 2}));
CHECK((sav3.bounds().strides() == index<2>{6, 2}));
CHECK((sav3.bounds().index_bounds() == multi_span_index<2>{2, 2}));
CHECK((sav3.bounds().strides() == multi_span_index<2>{6, 2}));
CHECK((sav3[{0, 0}] == 1 && sav3[{0, 1}] == 3 && sav3[{1, 0}] == 7));
}
@ -98,8 +103,8 @@ TEST_CASE("strided_span_constructors")
const multi_span<int> src = arr;
strided_span<int, 1> sav{src, {2, 1}};
CHECK(sav.bounds().index_bounds() == index<1>{2});
CHECK(sav.bounds().strides() == index<1>{1});
CHECK(sav.bounds().index_bounds() == multi_span_index<1>{2});
CHECK(sav.bounds().strides() == multi_span_index<1>{1});
CHECK(sav[1] == 2);
#if _MSC_VER > 1800
@ -110,8 +115,8 @@ TEST_CASE("strided_span_constructors")
strided_span<const int, 1> sav_c{multi_span<const int>{src},
strided_bounds<1>{2, 1}};
#endif
CHECK(sav_c.bounds().index_bounds() == index<1>{2});
CHECK(sav_c.bounds().strides() == index<1>{1});
CHECK(sav_c.bounds().index_bounds() == multi_span_index<1>{2});
CHECK(sav_c.bounds().strides() == multi_span_index<1>{1});
CHECK(sav_c[1] == 2);
#if _MSC_VER > 1800
@ -120,8 +125,8 @@ TEST_CASE("strided_span_constructors")
strided_span<volatile int, 1> sav_v{multi_span<volatile int>{src},
strided_bounds<1>{2, 1}};
#endif
CHECK(sav_v.bounds().index_bounds() == index<1>{2});
CHECK(sav_v.bounds().strides() == index<1>{1});
CHECK(sav_v.bounds().index_bounds() == multi_span_index<1>{2});
CHECK(sav_v.bounds().strides() == multi_span_index<1>{1});
CHECK(sav_v[1] == 2);
#if _MSC_VER > 1800
@ -130,8 +135,8 @@ TEST_CASE("strided_span_constructors")
strided_span<const volatile int, 1> sav_cv{multi_span<const volatile int>{src},
strided_bounds<1>{2, 1}};
#endif
CHECK(sav_cv.bounds().index_bounds() == index<1>{2});
CHECK(sav_cv.bounds().strides() == index<1>{1});
CHECK(sav_cv.bounds().index_bounds() == multi_span_index<1>{2});
CHECK(sav_cv.bounds().strides() == multi_span_index<1>{1});
CHECK(sav_cv[1] == 2);
}
@ -140,8 +145,8 @@ TEST_CASE("strided_span_constructors")
const multi_span<const int> src{arr};
strided_span<const int, 1> sav_c{src, {2, 1}};
CHECK(sav_c.bounds().index_bounds() == index<1>{2});
CHECK(sav_c.bounds().strides() == index<1>{1});
CHECK(sav_c.bounds().index_bounds() == multi_span_index<1>{2});
CHECK(sav_c.bounds().strides() == multi_span_index<1>{1});
CHECK(sav_c[1] == 2);
#if _MSC_VER > 1800
@ -151,8 +156,8 @@ TEST_CASE("strided_span_constructors")
strided_bounds<1>{2, 1}};
#endif
CHECK(sav_cv.bounds().index_bounds() == index<1>{2});
CHECK(sav_cv.bounds().strides() == index<1>{1});
CHECK(sav_cv.bounds().index_bounds() == multi_span_index<1>{2});
CHECK(sav_cv.bounds().strides() == multi_span_index<1>{1});
CHECK(sav_cv[1] == 2);
}
@ -161,8 +166,8 @@ TEST_CASE("strided_span_constructors")
const multi_span<volatile int> src{arr};
strided_span<volatile int, 1> sav_v{src, {2, 1}};
CHECK(sav_v.bounds().index_bounds() == index<1>{2});
CHECK(sav_v.bounds().strides() == index<1>{1});
CHECK(sav_v.bounds().index_bounds() == multi_span_index<1>{2});
CHECK(sav_v.bounds().strides() == multi_span_index<1>{1});
CHECK(sav_v[1] == 2);
#if _MSC_VER > 1800
@ -171,8 +176,8 @@ TEST_CASE("strided_span_constructors")
strided_span<const volatile int, 1> sav_cv{multi_span<const volatile int>{src},
strided_bounds<1>{2, 1}};
#endif
CHECK(sav_cv.bounds().index_bounds() == index<1>{2});
CHECK(sav_cv.bounds().strides() == index<1>{1});
CHECK(sav_cv.bounds().index_bounds() == multi_span_index<1>{2});
CHECK(sav_cv.bounds().strides() == multi_span_index<1>{1});
CHECK(sav_cv[1] == 2);
}
@ -181,8 +186,8 @@ TEST_CASE("strided_span_constructors")
const multi_span<const volatile int> src{arr};
strided_span<const volatile int, 1> sav_cv{src, {2, 1}};
CHECK(sav_cv.bounds().index_bounds() == index<1>{2});
CHECK(sav_cv.bounds().strides() == index<1>{1});
CHECK(sav_cv.bounds().index_bounds() == multi_span_index<1>{2});
CHECK(sav_cv.bounds().strides() == multi_span_index<1>{1});
CHECK(sav_cv[1] == 2);
}
}
@ -201,7 +206,7 @@ TEST_CASE("strided_span_constructors")
const strided_span<int, 1> src{arr, {2, 1}};
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[1] == 5);
@ -216,15 +221,15 @@ TEST_CASE("strided_span_constructors")
const strided_span<int, 1> src1{arr1, {2, 1}};
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[0] == 3);
int arr2[6] = {1, 2, 3, 4, 5, 6};
const strided_span<const int, 2> src2{arr2, {{3, 2}, {2, 1}}};
strided_span<const int, 2> sav2{src2};
CHECK((sav2.bounds().index_bounds() == index<2>{3, 2}));
CHECK((sav2.bounds().strides() == index<2>{2, 1}));
CHECK((sav2.bounds().index_bounds() == multi_span_index<2>{3, 2}));
CHECK((sav2.bounds().strides() == multi_span_index<2>{2, 1}));
CHECK((sav2[{0, 0}] == 1 && sav2[{2, 0}] == 5));
}
@ -236,8 +241,8 @@ TEST_CASE("strided_span_constructors")
const strided_span<int, 1> src{arr1, {{2}, {1}}};
strided_span<const int, 1> sav{arr2, {{3}, {2}}};
strided_span<const int, 1>& sav_ref = (sav = src);
CHECK(sav.bounds().index_bounds() == index<1>{2});
CHECK(sav.bounds().strides() == index<1>{1});
CHECK(sav.bounds().index_bounds() == multi_span_index<1>{2});
CHECK(sav.bounds().strides() == multi_span_index<1>{1});
CHECK(sav[0] == 1);
CHECK(&sav_ref == &sav);
}
@ -249,8 +254,8 @@ TEST_CASE("strided_span_constructors")
const strided_span<int, 1> src1{arr1, {2, 1}};
strided_span<int, 1> sav1{arr1b, {1, 1}};
strided_span<int, 1>& sav1_ref = (sav1 = src1);
CHECK(sav1.bounds().index_bounds() == index<1>{2});
CHECK(sav1.bounds().strides() == index<1>{1});
CHECK(sav1.bounds().index_bounds() == multi_span_index<1>{2});
CHECK(sav1.bounds().strides() == multi_span_index<1>{1});
CHECK(sav1[0] == 3);
CHECK(&sav1_ref == &sav1);
@ -259,8 +264,8 @@ TEST_CASE("strided_span_constructors")
const strided_span<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_ref = (sav2 = src2);
CHECK((sav2.bounds().index_bounds() == index<2>{3, 2}));
CHECK((sav2.bounds().strides() == index<2>{2, 1}));
CHECK((sav2.bounds().index_bounds() == multi_span_index<2>{3, 2}));
CHECK((sav2.bounds().strides() == multi_span_index<2>{2, 1}));
CHECK((sav2[{0, 0}] == 1 && sav2[{2, 0}] == 5));
CHECK(&sav2_ref == &sav2);
}
@ -317,7 +322,7 @@ TEST_CASE("strided_span_column_major")
// Section
strided_span<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, 1}] == 9));
CHECK((cm_sec[{1, 0}] == 11));
@ -366,7 +371,7 @@ TEST_CASE("strided_span_bounds")
{
// strided array ctor with matching strided bounds
strided_span<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_THROWS_AS(sav[4], fail_fast);
}
@ -374,7 +379,7 @@ TEST_CASE("strided_span_bounds")
{
// strided array ctor with smaller strided bounds
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_THROWS_AS(sav[2], fail_fast);
}
@ -382,7 +387,7 @@ TEST_CASE("strided_span_bounds")
{
// strided array ctor with fitting irregular bounds
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[1] == 3);
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>()),
{{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> sav9{arr, {{1, 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);
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.begin()[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}};
CHECK(empty_sav.bounds().index_bounds() == index<1>{0});
CHECK(empty_sav.bounds().index_bounds() == multi_span_index<1>{0});
CHECK_THROWS_AS(empty_sav[0], fail_fast);
CHECK_THROWS_AS(empty_sav.begin()[0], fail_fast);
CHECK_THROWS_AS(empty_sav.cbegin()[0], fail_fast);
@ -577,7 +582,7 @@ void iterate_every_other_element(multi_span<int, dynamic_range> av)
#if _MSC_VER > 1800
auto bounds = strided_bounds<1>({length}, {2});
#else
auto bounds = strided_bounds<1>(index<1>{length}, index<1>{2});
auto bounds = strided_bounds<1>(multi_span_index<1>{length}, multi_span_index<1>{2});
#endif
strided_span<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 j = 0; j < section.extent<1>(); ++j)
for (auto k = 0; k < section.extent<2>(); ++k) {
auto idx = index<3>{i, j, k}; // avoid braces in the CHECK macro
auto idx = multi_span_index<3>{i, j, k}; // avoid braces in the CHECK macro
CHECK(section[idx] == expected[2 * i + 2 * j + k]);
}
}

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/string_span>
#include <gsl/gsl_assert> // for Expects, fail_fast (ptr only)
#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 <cstdlib>
#include <map>
#include <vector>
#include <algorithm> // for move, find
#include <cstddef> // for size_t
#include <map> // for map
#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 gsl;
@ -507,12 +511,6 @@ TEST_CASE("Constructors")
CHECK(span.length() == 0);
}
// from nullptr
{
cstring_span<> span(nullptr);
CHECK(span.length() == 0);
}
// from string literal
{
cstring_span<> span = "Hello";

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;
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; }
TEST_CASE("finally_lambda")