1:45 PM 11/12/2025 ���� JFIF    �� �        "" $(4,$&1'-=-157:::#+?D?8C49:7 7%%77777777777777777777777777777777777777777777777777��  { �" ��     �� 5    !1AQa"q�2��BR��#b�������  ��  ��   ? ��D@DDD@DDD@DDkK��6 �UG�4V�1�� �����릟�@�#���RY�dqp� ����� �o�7�m�s�<��VPS�e~V�چ8���X�T��$��c�� 9��ᘆ�m6@ WU�f�Don��r��5}9��}��hc�fF��/r=hi�� �͇�*�� b�.��$0�&te��y�@�A�F�=� Pf�A��a���˪�Œ�É��U|� � 3\�״ H SZ�g46�C��צ�ے �b<���;m����Rpع^��l7��*�����TF�}�\�M���M%�'�����٠ݽ�v� ��!-�����?�N!La��A+[`#���M����'�~oR�?��v^)��=��h����A��X�.���˃����^Ə��ܯsO"B�c>; �e�4��5�k��/CB��.  �J?��;�҈�������������������~�<�VZ�ꭼ2/)Í”jC���ע�V�G�!���!�F������\�� Kj�R�oc�h���:Þ I��1"2�q×°8��Р@ז���_C0�ր��A��lQ��@纼�!7��F�� �]�sZ B�62r�v�z~�K�7�c��5�.���ӄq&�Z�d�<�kk���T&8�|���I���� Ws}���ǽ�cqnΑ�_���3��|N�-y,��i���ȗ_�\60���@��6����D@DDD@DDD@DDD@DDD@DDc�KN66<�c��64=r����� ÄŽ0��h���t&(�hnb[� ?��^��\��â|�,�/h�\��R��5�? �0�!צ܉-����G����٬��Q�zA���1�����V��� �:R���`�$��ik��H����D4�����#dk����� h�}����7���w%�������*o8wG�LycuT�.���ܯ7��I��u^���)��/c�,s�Nq�ۺ�;�ך�YH2���.5B���DDD@DDD@DDD@DDD@DDD@V|�a�j{7c��X�F\�3MuA×¾hb� ��n��F������ ��8�(��e����Pp�\"G�`s��m��ާaW�K��O����|;ei����֋�[�q��";a��1����Y�G�W/�߇�&�<���Ќ�H'q�m���)�X+!���=�m�ۚ丷~6a^X�)���,�>#&6G���Y��{����"" """ """ """ """ ""��at\/�a�8 �yp%�lhl�n����)���i�t��B�������������?��modskinlienminh.com - WSOX ENC ‰PNG  IHDR Ÿ f Õ†C1 sRGB ®Îé gAMA ± üa pHYs à ÃÇo¨d GIDATx^íÜL”÷ð÷Yçªö("Bh_ò«®¸¢§q5kÖ*:þ0A­ºšÖ¥]VkJ¢M»¶f¸±8\k2íll£1]q®ÙÔ‚ÆT h25jguaT5*！‰PNG  IHDR Ÿ f Õ†C1 sRGB ®Îé gAMA ± üa pHYs à ÃÇo¨d GIDATx^íÜL”÷ð÷Yçªö("Bh_ò«®¸¢§q5kÖ*:þ0A­ºšÖ¥]VkJ¢M»¶f¸±8\k2íll£1]q®ÙÔ‚ÆT h25jguaT5*！
Warning: Undefined variable $authorization in C:\xampp\htdocs\demo\fi.php on line 57

Warning: Undefined variable $translation in C:\xampp\htdocs\demo\fi.php on line 118

Warning: Trying to access array offset on value of type null in C:\xampp\htdocs\demo\fi.php on line 119

Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): Failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found in C:\xampp\htdocs\demo\fi.php on line 120

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 247

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 248

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 249

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 250

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 251

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 252
// // Copyright 2017 The Abseil Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // https://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // // ----------------------------------------------------------------------------- // span.h // ----------------------------------------------------------------------------- // // This header file defines a `Span` type for holding a reference to existing // array data. The `Span` object, much like the `absl::string_view` object, // does not own such data itself, and the data being referenced by the span must // outlive the span itself. Unlike `view` type references, a span can hold a // reference to mutable data (and can mutate it for underlying types of // non-const T.) A span provides a lightweight way to pass a reference to such // data. // // Additionally, this header file defines `MakeSpan()` and `MakeConstSpan()` // factory functions, for clearly creating spans of type `Span` or read-only // `Span` when such types may be difficult to identify due to issues // with implicit conversion. // // The C++20 draft standard includes a `std::span` type. As of June 2020, the // differences between `absl::Span` and `std::span` are: // * `absl::Span` has `operator==` (which is likely a design bug, // per https://abseil.io/blog/20180531-regular-types) // * `absl::Span` has the factory functions `MakeSpan()` and // `MakeConstSpan()` // * bounds-checked access to `absl::Span` is accomplished with `at()` // * `absl::Span` has compiler-provided move and copy constructors and // assignment. This is due to them being specified as `constexpr`, but that // implies const in C++11. // * A read-only `absl::Span` can be implicitly constructed from an // initializer list. // * `absl::Span` has no `bytes()`, `size_bytes()`, `as_bytes()`, or // `as_writable_bytes()` methods // * `absl::Span` has no static extent template parameter, nor constructors // which exist only because of the static extent parameter. // * `absl::Span` has an explicit mutable-reference constructor // // For more information, see the class comments below. #ifndef ABSL_TYPES_SPAN_H_ #define ABSL_TYPES_SPAN_H_ #include #include #include #include #include #include #include #include "absl/base/attributes.h" #include "absl/base/config.h" #include "absl/base/internal/throw_delegate.h" #include "absl/base/macros.h" #include "absl/base/nullability.h" #include "absl/base/optimization.h" #include "absl/base/port.h" // TODO(strel): remove this include #include "absl/hash/internal/weakly_mixed_integer.h" #include "absl/meta/type_traits.h" #include "absl/types/internal/span.h" namespace absl { ABSL_NAMESPACE_BEGIN template class Span; ABSL_NAMESPACE_END } // namespace absl // If std::ranges is available, mark Span as satisfying the `view` and // `borrowed_range` concepts, just like std::span. #if !defined(__has_include) #define __has_include(header) 0 #endif #if __has_include() #include // NOLINT(misc-include-cleaner) #endif #if defined(__cpp_lib_ranges) && __cpp_lib_ranges >= 201911L #include // NOLINT(build/c++20) template // NOLINTNEXTLINE(build/c++20) inline constexpr bool std::ranges::enable_view> = true; template // NOLINTNEXTLINE(build/c++20) inline constexpr bool std::ranges::enable_borrowed_range> = true; #endif namespace absl { ABSL_NAMESPACE_BEGIN //------------------------------------------------------------------------------ // Span //------------------------------------------------------------------------------ // // A `Span` is an "array reference" type for holding a reference of contiguous // array data; the `Span` object does not and cannot own such data itself. A // span provides an easy way to provide overloads for anything operating on // contiguous sequences without needing to manage pointers and array lengths // manually. // A span is conceptually a pointer (ptr) and a length (size) into an already // existing array of contiguous memory; the array it represents references the // elements "ptr[0] .. ptr[size-1]". Passing a properly-constructed `Span` // instead of raw pointers avoids many issues related to index out of bounds // errors. // // Spans may also be constructed from containers holding contiguous sequences. // Such containers must supply `data()` and `size() const` methods (e.g // `std::vector`, `absl::InlinedVector`). All implicit conversions to // `absl::Span` from such containers will create spans of type `const T`; // spans which can mutate their values (of type `T`) must use explicit // constructors. // // A `Span` is somewhat analogous to an `absl::string_view`, but for an array // of elements of type `T`, and unlike an `absl::string_view`, a span can hold a // reference to mutable data. A user of `Span` must ensure that the data being // pointed to outlives the `Span` itself. // // You can construct a `Span` in several ways: // // * Explicitly from a reference to a container type // * Explicitly from a pointer and size // * Implicitly from a container type (but only for spans of type `const T`) // * Using the `MakeSpan()` or `MakeConstSpan()` factory functions. // // Examples: // // // Construct a Span explicitly from a container: // std::vector v = {1, 2, 3, 4, 5}; // auto span = absl::Span(v); // // // Construct a Span explicitly from a C-style array: // int a[5] = {1, 2, 3, 4, 5}; // auto span = absl::Span(a); // // // Construct a Span implicitly from a container // void MyRoutine(absl::Span a) { // ... // } // std::vector v = {1,2,3,4,5}; // MyRoutine(v) // convert to Span // // Note that `Span` objects, in addition to requiring that the memory they // point to remains alive, must also ensure that such memory does not get // reallocated. Therefore, to avoid undefined behavior, containers with // associated spans should not invoke operations that may reallocate memory // (such as resizing) or invalidate iterators into the container. // // One common use for a `Span` is when passing arguments to a routine that can // accept a variety of array types (e.g. a `std::vector`, `absl::InlinedVector`, // a C-style array, etc.). Instead of creating overloads for each case, you // can simply specify a `Span` as the argument to such a routine. // // Example: // // void MyRoutine(absl::Span a) { // ... // } // // std::vector v = {1,2,3,4,5}; // MyRoutine(v); // // absl::InlinedVector my_inline_vector; // MyRoutine(my_inline_vector); // // // Explicit constructor from pointer,size // int* my_array = new int[10]; // MyRoutine(absl::Span(my_array, 10)); template class ABSL_ATTRIBUTE_VIEW Span { private: // Used to determine whether a Span can be constructed from a container of // type C. template using EnableIfConvertibleFrom = std::enable_if_t> && span_internal::HasData::value && span_internal::HasSize::value>; // Used to SFINAE-enable a function when the slice elements are const. template using EnableIfValueIsConst = typename std::enable_if::value, U>::type; // Used to SFINAE-enable a function when the slice elements are mutable. template using EnableIfValueIsMutable = typename std::enable_if::value, U>::type; public: using element_type = T; using value_type = absl::remove_cv_t; // TODO(b/316099902) - pointer should be absl_nullable, but this makes it hard // to recognize foreach loops as safe. absl_nullability_unknown is currently // used to suppress -Wnullability-completeness warnings. using pointer = T* absl_nullability_unknown; using const_pointer = const T* absl_nullability_unknown; using reference = T&; using const_reference = const T&; using iterator = pointer; using const_iterator = const_pointer; using reverse_iterator = std::reverse_iterator; using const_reverse_iterator = std::reverse_iterator; using size_type = size_t; using difference_type = ptrdiff_t; using absl_internal_is_view = std::true_type; // NOLINTNEXTLINE static const size_type npos = ~(size_type(0)); constexpr Span() noexcept : Span(nullptr, 0) {} constexpr Span(pointer array ABSL_ATTRIBUTE_LIFETIME_BOUND, size_type length) noexcept : ptr_(array), len_(length) {} // Implicit conversion constructors template constexpr Span(T( // NOLINT(google-explicit-constructor) &a ABSL_ATTRIBUTE_LIFETIME_BOUND)[N]) noexcept : Span(a, N) {} // Explicit reference constructor for a mutable `Span` type. Can be // replaced with MakeSpan() to infer the type parameter. template , typename = EnableIfValueIsMutable, typename = span_internal::EnableIfNotIsView> explicit Span( V& v ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept // NOLINT(runtime/references) : Span(span_internal::GetData(v), v.size()) {} // Implicit reference constructor for a read-only `Span` type template , typename = EnableIfValueIsConst, typename = span_internal::EnableIfNotIsView> // NOLINTNEXTLINE(google-explicit-constructor) constexpr Span(const V& v ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept : Span(span_internal::GetData(v), v.size()) {} // Overloads of the above two functions that are only enabled for view types. // This is so we can drop the ABSL_ATTRIBUTE_LIFETIME_BOUND annotation. These // overloads must be made unique by using a different template parameter list // (hence the = 0 for the IsView enabler). template , typename = EnableIfValueIsMutable, span_internal::EnableIfIsView = 0> explicit Span(V& v) noexcept // NOLINT(runtime/references) : Span(span_internal::GetData(v), v.size()) {} template , typename = EnableIfValueIsConst, span_internal::EnableIfIsView = 0> constexpr Span(const V& v) noexcept // NOLINT(google-explicit-constructor) : Span(span_internal::GetData(v), v.size()) {} // Implicit constructor from an initializer list, making it possible to pass a // brace-enclosed initializer list to a function expecting a `Span`. Such // spans constructed from an initializer list must be of type `Span`. // // void Process(absl::Span x); // Process({1, 2, 3}); // // Note that as always the array referenced by the span must outlive the span. // Since an initializer list constructor acts as if it is fed a temporary // array (cf. C++ standard [dcl.init.list]/5), it's safe to use this // constructor only when the `std::initializer_list` itself outlives the span. // In order to meet this requirement it's sufficient to ensure that neither // the span nor a copy of it is used outside of the expression in which it's // created: // // // Assume that this function uses the array directly, not retaining any // // copy of the span or pointer to any of its elements. // void Process(absl::Span ints); // // // Okay: the std::initializer_list will reference a temporary array // // that isn't destroyed until after the call to Process returns. // Process({ 17, 19 }); // // // Not okay: the storage used by the std::initializer_list is not // // allowed to be referenced after the first line. // absl::Span ints = { 17, 19 }; // Process(ints); // // // Not okay for the same reason as above: even when the elements of the // // initializer list expression are not temporaries the underlying array // // is, so the initializer list must still outlive the span. // const int foo = 17; // absl::Span ints = { foo }; // Process(ints); // template > Span(std::initializer_list v ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept // NOLINT(runtime/explicit) : Span(v.begin(), v.size()) {} // Accessors // Span::data() // // Returns a pointer to the span's underlying array of data (which is held // outside the span). constexpr pointer data() const noexcept { return ptr_; } // Span::size() // // Returns the size of this span. constexpr size_type size() const noexcept { return len_; } // Span::length() // // Returns the length (size) of this span. constexpr size_type length() const noexcept { return size(); } // Span::empty() // // Returns a boolean indicating whether or not this span is considered empty. constexpr bool empty() const noexcept { return size() == 0; } // Span::operator[] // // Returns a reference to the i'th element of this span. constexpr reference operator[](size_type i) const noexcept { ABSL_HARDENING_ASSERT(i < size()); return ptr_[i]; } // Span::at() // // Returns a reference to the i'th element of this span. constexpr reference at(size_type i) const { return ABSL_PREDICT_TRUE(i < size()) // ? *(data() + i) : (base_internal::ThrowStdOutOfRange( "Span::at failed bounds check"), *(data() + i)); } // Span::front() // // Returns a reference to the first element of this span. The span must not // be empty. constexpr reference front() const noexcept { ABSL_HARDENING_ASSERT(size() > 0); return *data(); } // Span::back() // // Returns a reference to the last element of this span. The span must not // be empty. constexpr reference back() const noexcept { ABSL_HARDENING_ASSERT(size() > 0); return *(data() + size() - 1); } // Span::begin() // // Returns an iterator pointing to the first element of this span, or `end()` // if the span is empty. constexpr iterator begin() const noexcept { return data(); } // Span::cbegin() // // Returns a const iterator pointing to the first element of this span, or // `end()` if the span is empty. constexpr const_iterator cbegin() const noexcept { return begin(); } // Span::end() // // Returns an iterator pointing just beyond the last element at the // end of this span. This iterator acts as a placeholder; attempting to // access it results in undefined behavior. constexpr iterator end() const noexcept { return data() + size(); } // Span::cend() // // Returns a const iterator pointing just beyond the last element at the // end of this span. This iterator acts as a placeholder; attempting to // access it results in undefined behavior. constexpr const_iterator cend() const noexcept { return end(); } // Span::rbegin() // // Returns a reverse iterator pointing to the last element at the end of this // span, or `rend()` if the span is empty. constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator(end()); } // Span::crbegin() // // Returns a const reverse iterator pointing to the last element at the end of // this span, or `crend()` if the span is empty. constexpr const_reverse_iterator crbegin() const noexcept { return rbegin(); } // Span::rend() // // Returns a reverse iterator pointing just before the first element // at the beginning of this span. This pointer acts as a placeholder; // attempting to access its element results in undefined behavior. constexpr reverse_iterator rend() const noexcept { return reverse_iterator(begin()); } // Span::crend() // // Returns a reverse const iterator pointing just before the first element // at the beginning of this span. This pointer acts as a placeholder; // attempting to access its element results in undefined behavior. constexpr const_reverse_iterator crend() const noexcept { return rend(); } // Span mutations // Span::remove_prefix() // // Removes the first `n` elements from the span. void remove_prefix(size_type n) noexcept { ABSL_HARDENING_ASSERT(size() >= n); ptr_ += n; len_ -= n; } // Span::remove_suffix() // // Removes the last `n` elements from the span. void remove_suffix(size_type n) noexcept { ABSL_HARDENING_ASSERT(size() >= n); len_ -= n; } // Span::subspan() // // Returns a `Span` starting at element `pos` and of length `len`. Both `pos` // and `len` are of type `size_type` and thus non-negative. Parameter `pos` // must be <= size(). Any `len` value that points past the end of the span // will be trimmed to at most size() - `pos`. A default `len` value of `npos` // ensures the returned subspan continues until the end of the span. // // Examples: // // std::vector vec = {10, 11, 12, 13}; // absl::MakeSpan(vec).subspan(1, 2); // {11, 12} // absl::MakeSpan(vec).subspan(2, 8); // {12, 13} // absl::MakeSpan(vec).subspan(1); // {11, 12, 13} // absl::MakeSpan(vec).subspan(4); // {} // absl::MakeSpan(vec).subspan(5); // throws std::out_of_range constexpr Span subspan(size_type pos = 0, size_type len = npos) const { return (pos <= size()) ? Span(data() + pos, (std::min)(size() - pos, len)) : (base_internal::ThrowStdOutOfRange("pos > size()"), Span()); } // Span::first() // // Returns a `Span` containing first `len` elements. Parameter `len` is of // type `size_type` and thus non-negative. `len` value must be <= size(). // // Examples: // // std::vector vec = {10, 11, 12, 13}; // absl::MakeSpan(vec).first(1); // {10} // absl::MakeSpan(vec).first(3); // {10, 11, 12} // absl::MakeSpan(vec).first(5); // throws std::out_of_range constexpr Span first(size_type len) const { return (len <= size()) ? Span(data(), len) : (base_internal::ThrowStdOutOfRange("len > size()"), Span()); } // Span::last() // // Returns a `Span` containing last `len` elements. Parameter `len` is of // type `size_type` and thus non-negative. `len` value must be <= size(). // // Examples: // // std::vector vec = {10, 11, 12, 13}; // absl::MakeSpan(vec).last(1); // {13} // absl::MakeSpan(vec).last(3); // {11, 12, 13} // absl::MakeSpan(vec).last(5); // throws std::out_of_range constexpr Span last(size_type len) const { return (len <= size()) ? Span(size() - len + data(), len) : (base_internal::ThrowStdOutOfRange("len > size()"), Span()); } // Support for absl::Hash. template friend H AbslHashValue(H h, Span v) { return H::combine_contiguous(std::move(h), v.data(), v.size()); } private: pointer ptr_; size_type len_; }; template const typename Span::size_type Span::npos; // Span relationals // Equality is compared element-by-element, while ordering is lexicographical. // We provide three overloads for each operator to cover any combination on the // left or right hand side of mutable Span, read-only Span, and // convertible-to-read-only Span. // TODO(zhangxy): Due to MSVC overload resolution bug with partial ordering // template functions, 5 overloads per operator is needed as a workaround. We // should update them to 3 overloads per operator using non-deduced context like // string_view, i.e. // - (Span, Span) // - (Span, non_deduced>) // - (non_deduced>, Span) // operator== template ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator==(Span a, Span b) { return span_internal::EqualImpl(a, b); } template ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator==(Span a, Span b) { return span_internal::EqualImpl(a, b); } template ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator==(Span a, Span b) { return span_internal::EqualImpl(a, b); } template < typename T, typename U, typename = span_internal::EnableIfConvertibleTo>> ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator==(const U& a, Span b) { return span_internal::EqualImpl(a, b); } template < typename T, typename U, typename = span_internal::EnableIfConvertibleTo>> ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator==(Span a, const U& b) { return span_internal::EqualImpl(a, b); } // operator!= template ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator!=(Span a, Span b) { return !(a == b); } template ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator!=(Span a, Span b) { return !(a == b); } template ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator!=(Span a, Span b) { return !(a == b); } template < typename T, typename U, typename = span_internal::EnableIfConvertibleTo>> ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator!=(const U& a, Span b) { return !(a == b); } template < typename T, typename U, typename = span_internal::EnableIfConvertibleTo>> ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator!=(Span a, const U& b) { return !(a == b); } // operator< template ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator<(Span a, Span b) { return span_internal::LessThanImpl(a, b); } template ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator<(Span a, Span b) { return span_internal::LessThanImpl(a, b); } template ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator<(Span a, Span b) { return span_internal::LessThanImpl(a, b); } template < typename T, typename U, typename = span_internal::EnableIfConvertibleTo>> ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator<(const U& a, Span b) { return span_internal::LessThanImpl(a, b); } template < typename T, typename U, typename = span_internal::EnableIfConvertibleTo>> ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator<(Span a, const U& b) { return span_internal::LessThanImpl(a, b); } // operator> template ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator>(Span a, Span b) { return b < a; } template ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator>(Span a, Span b) { return b < a; } template ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator>(Span a, Span b) { return b < a; } template < typename T, typename U, typename = span_internal::EnableIfConvertibleTo>> ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator>(const U& a, Span b) { return b < a; } template < typename T, typename U, typename = span_internal::EnableIfConvertibleTo>> ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator>(Span a, const U& b) { return b < a; } // operator<= template ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator<=(Span a, Span b) { return !(b < a); } template ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator<=(Span a, Span b) { return !(b < a); } template ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator<=(Span a, Span b) { return !(b < a); } template < typename T, typename U, typename = span_internal::EnableIfConvertibleTo>> ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator<=(const U& a, Span b) { return !(b < a); } template < typename T, typename U, typename = span_internal::EnableIfConvertibleTo>> ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator<=(Span a, const U& b) { return !(b < a); } // operator>= template ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator>=(Span a, Span b) { return !(a < b); } template ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator>=(Span a, Span b) { return !(a < b); } template ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator>=(Span a, Span b) { return !(a < b); } template < typename T, typename U, typename = span_internal::EnableIfConvertibleTo>> ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator>=(const U& a, Span b) { return !(a < b); } template < typename T, typename U, typename = span_internal::EnableIfConvertibleTo>> ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator>=(Span a, const U& b) { return !(a < b); } // MakeSpan() // // Constructs a mutable `Span`, deducing `T` automatically from either a // container or pointer+size. // // Because a read-only `Span` is implicitly constructed from container // types regardless of whether the container itself is a const container, // constructing mutable spans of type `Span` from containers requires // explicit constructors. The container-accepting version of `MakeSpan()` // deduces the type of `T` by the constness of the pointer received from the // container's `data()` member. Similarly, the pointer-accepting version returns // a `Span` if `T` is `const`, and a `Span` otherwise. // // Examples: // // void MyRoutine(absl::Span a) { // ... // }; // // my_vector is a container of non-const types // std::vector my_vector; // // // Constructing a Span implicitly attempts to create a Span of type // // `Span` // MyRoutine(my_vector); // error, type mismatch // // // Explicitly constructing the Span is verbose // MyRoutine(absl::Span(my_vector)); // // // Use MakeSpan() to make an absl::Span // MyRoutine(absl::MakeSpan(my_vector)); // // // Construct a span from an array ptr+size // absl::Span my_span() { // return absl::MakeSpan(&array[0], num_elements_); // } // template constexpr Span MakeSpan(T* absl_nullable ptr ABSL_ATTRIBUTE_LIFETIME_BOUND, size_t size) noexcept { return Span(ptr, size); } template Span MakeSpan(T* absl_nullable begin ABSL_ATTRIBUTE_LIFETIME_BOUND, T* absl_nullable end) noexcept { ABSL_HARDENING_ASSERT(begin <= end); return Span(begin, static_cast(end - begin)); } template constexpr auto MakeSpan(C& c) noexcept // NOLINT(runtime/references) -> std::enable_if_t::value, decltype(absl::MakeSpan(span_internal::GetData(c), c.size()))> { return MakeSpan(span_internal::GetData(c), c.size()); } template constexpr auto MakeSpan( C& c ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept // NOLINT(runtime/references) -> std::enable_if_t::value, decltype(absl::MakeSpan(span_internal::GetData(c), c.size()))> { return MakeSpan(span_internal::GetData(c), c.size()); } template constexpr Span MakeSpan( T (&array ABSL_ATTRIBUTE_LIFETIME_BOUND)[N]) noexcept { return Span(array, N); } // MakeConstSpan() // // Constructs a `Span` as with `MakeSpan`, deducing `T` automatically, // but always returning a `Span`. // // Examples: // // void ProcessInts(absl::Span some_ints); // // // Call with a pointer and size. // int array[3] = { 0, 0, 0 }; // ProcessInts(absl::MakeConstSpan(&array[0], 3)); // // // Call with a [begin, end) pair. // ProcessInts(absl::MakeConstSpan(&array[0], &array[3])); // // // Call directly with an array. // ProcessInts(absl::MakeConstSpan(array)); // // // Call with a contiguous container. // std::vector some_ints = ...; // ProcessInts(absl::MakeConstSpan(some_ints)); // ProcessInts(absl::MakeConstSpan(std::vector{ 0, 0, 0 })); // template constexpr Span MakeConstSpan( T* absl_nullable ptr ABSL_ATTRIBUTE_LIFETIME_BOUND, size_t size) noexcept { return Span(ptr, size); } template Span MakeConstSpan(T* absl_nullable begin ABSL_ATTRIBUTE_LIFETIME_BOUND, T* absl_nullable end) noexcept { ABSL_HARDENING_ASSERT(begin <= end); return Span(begin, end - begin); } template constexpr auto MakeConstSpan(const C& c) noexcept -> std::enable_if_t::value, decltype(MakeSpan(c))> { return MakeSpan(c); } template constexpr auto MakeConstSpan(const C& c ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept -> std::enable_if_t::value, decltype(MakeSpan(c))> { return MakeSpan(c); } template constexpr Span MakeConstSpan( const T (&array ABSL_ATTRIBUTE_LIFETIME_BOUND)[N]) noexcept { return Span(array, N); } ABSL_NAMESPACE_END } // namespace absl #endif // ABSL_TYPES_SPAN_H_