| // |
| // Copyright 2019 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. |
| // |
| #ifndef ABSL_TYPES_INTERNAL_SPAN_H_ |
| #define ABSL_TYPES_INTERNAL_SPAN_H_ |
| |
| #include <algorithm> |
| #include <cstddef> |
| #include <string> |
| #include <type_traits> |
| |
| #include "absl/algorithm/algorithm.h" |
| #include "absl/base/internal/throw_delegate.h" |
| #include "absl/meta/type_traits.h" |
| |
| namespace absl { |
| ABSL_NAMESPACE_BEGIN |
| |
| namespace span_internal { |
| // A constexpr min function |
| constexpr size_t Min(size_t a, size_t b) noexcept { return a < b ? a : b; } |
| |
| // Wrappers for access to container data pointers. |
| template <typename C> |
| constexpr auto GetDataImpl(C& c, char) noexcept // NOLINT(runtime/references) |
| -> decltype(c.data()) { |
| return c.data(); |
| } |
| |
| // Before C++17, std::string::data returns a const char* in all cases. |
| inline char* GetDataImpl(std::string& s, // NOLINT(runtime/references) |
| int) noexcept { |
| return &s[0]; |
| } |
| |
| template <typename C> |
| constexpr auto GetData(C& c) noexcept // NOLINT(runtime/references) |
| -> decltype(GetDataImpl(c, 0)) { |
| return GetDataImpl(c, 0); |
| } |
| |
| // Detection idioms for size() and data(). |
| template <typename C> |
| using HasSize = |
| std::is_integral<absl::decay_t<decltype(std::declval<C&>().size())>>; |
| |
| // We want to enable conversion from vector<T*> to Span<const T* const> but |
| // disable conversion from vector<Derived> to Span<Base>. Here we use |
| // the fact that U** is convertible to Q* const* if and only if Q is the same |
| // type or a more cv-qualified version of U. We also decay the result type of |
| // data() to avoid problems with classes which have a member function data() |
| // which returns a reference. |
| template <typename T, typename C> |
| using HasData = |
| std::is_convertible<absl::decay_t<decltype(GetData(std::declval<C&>()))>*, |
| T* const*>; |
| |
| // Extracts value type from a Container |
| template <typename C> |
| struct ElementType { |
| using type = typename absl::remove_reference_t<C>::value_type; |
| }; |
| |
| template <typename T, size_t N> |
| struct ElementType<T (&)[N]> { |
| using type = T; |
| }; |
| |
| template <typename C> |
| using ElementT = typename ElementType<C>::type; |
| |
| template <typename T> |
| using EnableIfMutable = |
| typename std::enable_if<!std::is_const<T>::value, int>::type; |
| |
| template <template <typename> class SpanT, typename T> |
| bool EqualImpl(SpanT<T> a, SpanT<T> b) { |
| static_assert(std::is_const<T>::value, ""); |
| return absl::equal(a.begin(), a.end(), b.begin(), b.end()); |
| } |
| |
| template <template <typename> class SpanT, typename T> |
| bool LessThanImpl(SpanT<T> a, SpanT<T> b) { |
| // We can't use value_type since that is remove_cv_t<T>, so we go the long way |
| // around. |
| static_assert(std::is_const<T>::value, ""); |
| return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end()); |
| } |
| |
| // The `IsConvertible` classes here are needed because of the |
| // `std::is_convertible` bug in libcxx when compiled with GCC. This build |
| // configuration is used by Android NDK toolchain. Reference link: |
| // https://bugs.llvm.org/show_bug.cgi?id=27538. |
| template <typename From, typename To> |
| struct IsConvertibleHelper { |
| private: |
| static std::true_type testval(To); |
| static std::false_type testval(...); |
| |
| public: |
| using type = decltype(testval(std::declval<From>())); |
| }; |
| |
| template <typename From, typename To> |
| struct IsConvertible : IsConvertibleHelper<From, To>::type {}; |
| |
| // TODO(zhangxy): replace `IsConvertible` with `std::is_convertible` once the |
| // older version of libcxx is not supported. |
| template <typename From, typename To> |
| using EnableIfConvertibleTo = |
| typename std::enable_if<IsConvertible<From, To>::value>::type; |
| } // namespace span_internal |
| ABSL_NAMESPACE_END |
| } // namespace absl |
| |
| #endif // ABSL_TYPES_INTERNAL_SPAN_H_ |