diff options
Diffstat (limited to 'gsl/span')
| -rw-r--r-- | gsl/span | 673 |
1 files changed, 673 insertions, 0 deletions
diff --git a/gsl/span b/gsl/span new file mode 100644 index 0000000..cf90e86 --- /dev/null +++ b/gsl/span @@ -0,0 +1,673 @@ + +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +/////////////////////////////////////////////////////////////////////////////// + +#pragma once + +#ifndef GSL_SPAN_H +#define GSL_SPAN_H + +#include "gsl_assert" +#include "gsl_byte" +#include "gsl_util" +#include <array> +#include <iterator> +#include <limits> +#include <stdexcept> +#include <type_traits> +#include <utility> + +#ifdef _MSC_VER + +#pragma warning(push) + +// turn off some warnings that are noisy about our Expects statements +#pragma warning(disable : 4127) // conditional expression is constant + +// blanket turn off warnings from CppCoreCheck for now +// so people aren't annoyed by them when running the tool. +// more targeted suppressions will be added in a future update to the GSL +#pragma warning(disable : 26481 26482 26483 26485 26490 26491 26492 26493 26495) + +// No MSVC does constexpr fully yet +#pragma push_macro("constexpr") +#define constexpr /*constexpr*/ + +// VS 2013 workarounds +#if _MSC_VER <= 1800 + +#define GSL_MSVC_HAS_VARIADIC_CTOR_BUG +#define GSL_MSVC_NO_DEFAULT_MOVE_CTOR +#define GSL_MSVC_NO_CPP14_STD_EQUAL + +// noexcept is not understood +#ifndef GSL_THROW_ON_CONTRACT_VIOLATION +#pragma push_macro("noexcept") +#define noexcept /*noexcept*/ +#endif + +#pragma push_macro("alignof") +#define alignof __alignof + +// turn off some misguided warnings +#pragma warning(push) +#pragma warning(disable : 4351) // warns about newly introduced aggregate initializer behavior +#pragma warning(disable : 4512) // warns that assignment op could not be generated + +#endif // _MSC_VER <= 1800 + +#endif // _MSC_VER + +#ifdef GSL_THROW_ON_CONTRACT_VIOLATION + +#ifdef _MSC_VER +#pragma push_macro("noexcept") +#endif + +#define noexcept /*noexcept*/ + +#endif // GSL_THROW_ON_CONTRACT_VIOLATION + +namespace gsl +{ + +// [views.constants], constants +constexpr const std::ptrdiff_t dynamic_extent = -1; + +template <class ElementType, std::ptrdiff_t Extent = dynamic_extent> +class span; + +// implementation details +namespace details +{ + template <class T> + struct is_span_oracle : std::false_type + { + }; + + template <class ElementType, std::ptrdiff_t Extent> + struct is_span_oracle<gsl::span<ElementType, Extent>> : std::true_type + { + }; + + template <class T> + struct is_span : public is_span_oracle<std::remove_cv_t<T>> + { + }; + + template <class T> + struct is_std_array_oracle : std::false_type + { + }; + + template <class ElementType, size_t Extent> + struct is_std_array_oracle<std::array<ElementType, Extent>> : std::true_type + { + }; + + template <class T> + struct is_std_array : public is_std_array_oracle<std::remove_cv_t<T>> + { + }; + + template <std::ptrdiff_t From, std::ptrdiff_t To> + struct is_allowed_extent_conversion + : public std::integral_constant<bool, From == To || From == gsl::dynamic_extent || + To == gsl::dynamic_extent> + { + }; + + template <class From, class To> + struct is_allowed_element_type_conversion + : public std::integral_constant<bool, std::is_convertible<From (*)[], To (*)[]>::value> + { + }; + + template <class Span, bool IsConst> + class span_iterator + { + public: + using iterator_category = std::random_access_iterator_tag; + using value_type = + std::conditional_t<IsConst, std::add_const_t<typename Span::element_type>, + typename Span::element_type>; + using difference_type = typename Span::index_type; + + using pointer = std::add_pointer_t<value_type>; + using reference = std::add_lvalue_reference_t<value_type>; + + constexpr span_iterator() noexcept : span_iterator(nullptr, 0) {} + + constexpr span_iterator(const Span* span, typename Span::index_type index) + : span_(span), index_(index) + { + Expects(span == nullptr || (index_ >= 0 && index <= span_->length())); + } + + friend class span_iterator<Span, true>; + constexpr span_iterator(const span_iterator<Span, false>& other) noexcept + : span_iterator(other.span_, other.index_) + { + } + + constexpr span_iterator<Span, IsConst>& operator=(const span_iterator<Span, IsConst>&) noexcept = default; + + constexpr reference operator*() const + { + Expects(span_); + return (*span_)[index_]; + } + + constexpr pointer operator->() const + { + Expects(span_); + return &((*span_)[index_]); + } + + constexpr span_iterator& operator++() noexcept + { + Expects(span_ && index_ >= 0 && index_ < span_->length()); + ++index_; + return *this; + } + + constexpr span_iterator operator++(int) noexcept + { + auto ret = *this; + ++(*this); + return ret; + } + + constexpr span_iterator& operator--() noexcept + { + Expects(span_ && index_ > 0 && index_ <= span_->length()); + --index_; + return *this; + } + + constexpr span_iterator operator--(int) noexcept + { + auto ret = *this; + --(*this); + return ret; + } + + constexpr span_iterator operator+(difference_type n) const noexcept + { + auto ret = *this; + return ret += n; + } + + constexpr span_iterator& operator+=(difference_type n) noexcept + { + Expects(span_ && (index_ + n) >= 0 && (index_ + n) <= span_->length()); + index_ += n; + return *this; + } + + constexpr span_iterator operator-(difference_type n) const noexcept + { + auto ret = *this; + return ret -= n; + } + + constexpr span_iterator& operator-=(difference_type n) noexcept { return *this += -n; } + + constexpr difference_type operator-(const span_iterator& rhs) const noexcept + { + Expects(span_ == rhs.span_); + return index_ - rhs.index_; + } + + constexpr reference operator[](difference_type n) const noexcept { return *(*this + n); } + + constexpr friend bool operator==(const span_iterator& lhs, + const span_iterator& rhs) noexcept + { + return lhs.span_ == rhs.span_ && lhs.index_ == rhs.index_; + } + + constexpr friend bool operator!=(const span_iterator& lhs, + const span_iterator& rhs) noexcept + { + return !(lhs == rhs); + } + + constexpr friend bool operator<(const span_iterator& lhs, const span_iterator& rhs) noexcept + { + Expects(lhs.span_ == rhs.span_); + return lhs.index_ < rhs.index_; + } + + constexpr friend bool operator<=(const span_iterator& lhs, + const span_iterator& rhs) noexcept + { + return !(rhs < lhs); + } + + constexpr friend bool operator>(const span_iterator& lhs, const span_iterator& rhs) noexcept + { + return rhs < lhs; + } + + constexpr friend bool operator>=(const span_iterator& lhs, + const span_iterator& rhs) noexcept + { + return !(rhs > lhs); + } + + void swap(span_iterator& rhs) noexcept + { + std::swap(index_, rhs.index_); + std::swap(span_, rhs.span_); + } + + protected: + const Span* span_; + std::ptrdiff_t index_; + }; + + template <class Span, bool IsConst> + constexpr span_iterator<Span, IsConst> + operator+(typename span_iterator<Span, IsConst>::difference_type n, + const span_iterator<Span, IsConst>& rhs) noexcept + { + return rhs + n; + } + + template <class Span, bool IsConst> + constexpr span_iterator<Span, IsConst> + operator-(typename span_iterator<Span, IsConst>::difference_type n, + const span_iterator<Span, IsConst>& rhs) noexcept + { + return rhs - n; + } + + template <std::ptrdiff_t Ext> + class extent_type + { + public: + using index_type = std::ptrdiff_t; + + static_assert(Ext >= 0, "A fixed-size span must be >= 0 in size."); + + constexpr extent_type() noexcept {} + + template <index_type Other> + constexpr extent_type(extent_type<Other> ext) noexcept + { + static_assert(Other == Ext || Other == dynamic_extent, + "Mismatch between fixed-size extent and size of initializing data."); + Expects(ext.size() == Ext); + } + + constexpr extent_type(index_type size) { Expects(size == Ext); } + + constexpr inline index_type size() const noexcept { return Ext; } + }; + + template <> + class extent_type<dynamic_extent> + { + public: + using index_type = std::ptrdiff_t; + + template <index_type Other> + explicit constexpr extent_type(extent_type<Other> ext) : size_(ext.size()) + { + } + + explicit constexpr extent_type(index_type size) : size_(size) { Expects(size >= 0); } + + constexpr inline index_type size() const noexcept { return size_; } + + private: + index_type size_; + }; +} // namespace details + +// [span], class template span +template <class ElementType, std::ptrdiff_t Extent> +class span +{ +public: + // constants and types + using element_type = ElementType; + using index_type = std::ptrdiff_t; + using pointer = element_type*; + using reference = element_type&; + + using iterator = details::span_iterator<span<ElementType, Extent>, false>; + using const_iterator = details::span_iterator<span<ElementType, Extent>, true>; + using reverse_iterator = std::reverse_iterator<iterator>; + using const_reverse_iterator = std::reverse_iterator<const_iterator>; + + constexpr static const index_type extent = Extent; + + // [span.cons], span constructors, copy, assignment, and destructor + constexpr span() noexcept : storage_(nullptr, details::extent_type<0>()) {} + + constexpr span(std::nullptr_t) noexcept : span() {} + + constexpr span(pointer ptr, index_type count) : storage_(ptr, count) {} + + constexpr span(pointer firstElem, pointer lastElem) + : storage_(firstElem, std::distance(firstElem, lastElem)) + { + } + + template <size_t N> + constexpr span(element_type (&arr)[N]) noexcept : storage_(&arr[0], details::extent_type<N>()) + { + } + + template <size_t N, class ArrayElementType = std::remove_const_t<element_type>> + constexpr span(std::array<ArrayElementType, N>& arr) noexcept + : storage_(&arr[0], details::extent_type<N>()) + { + } + + template <size_t N> + constexpr span(const std::array<std::remove_const_t<element_type>, N>& arr) noexcept + : storage_(&arr[0], details::extent_type<N>()) + { + } + + // 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, + class = std::enable_if_t< + !details::is_span<Container>::value && !details::is_std_array<Container>::value && + std::is_convertible<typename Container::pointer, pointer>::value && + std::is_convertible<typename Container::pointer, + decltype(std::declval<Container>().data())>::value>> + constexpr span(Container& cont) : span(cont.data(), narrow<index_type>(cont.size())) + { + } + + template <class Container, + class = std::enable_if_t< + std::is_const<element_type>::value && !details::is_span<Container>::value && + std::is_convertible<typename Container::pointer, pointer>::value && + std::is_convertible<typename Container::pointer, + decltype(std::declval<Container>().data())>::value>> + constexpr span(const Container& cont) : span(cont.data(), narrow<index_type>(cont.size())) + { + } + + constexpr span(const span& other) noexcept = default; +#ifndef GSL_MSVC_NO_DEFAULT_MOVE_CTOR + constexpr span(span&& other) noexcept = default; +#else + constexpr span(span&& other) noexcept : storage_(std::move(other.storage_)) {} +#endif + + 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(const span<OtherElementType, OtherExtent>& other) + : storage_(other.data(), details::extent_type<OtherExtent>(other.size())) + { + } + + 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() noexcept = default; + constexpr span& operator=(const span& other) noexcept = default; + +#ifndef GSL_MSVC_NO_DEFAULT_MOVE_CTOR + constexpr span& operator=(span&& other) noexcept = default; +#else + constexpr span& operator=(span&& other) noexcept + { + storage_ = std::move(other.storage_); + return *this; + } +#endif + // [span.sub], span subviews + template <std::ptrdiff_t Count> + constexpr span<element_type, Count> first() const + { + Expects(Count >= 0 && Count <= size()); + return {data(), Count}; + } + + template <std::ptrdiff_t Count> + constexpr span<element_type, Count> last() const + { + Expects(Count >= 0 && Count <= size()); + return {data() + (size() - Count), Count}; + } + + template <std::ptrdiff_t Offset, std::ptrdiff_t Count = dynamic_extent> + constexpr span<element_type, Count> subspan() const + { + Expects((Offset == 0 || (Offset > 0 && Offset <= size())) && + (Count == dynamic_extent || (Count >= 0 && Offset + Count <= size()))); + return {data() + Offset, Count == dynamic_extent ? size() - Offset : Count}; + } + + constexpr span<element_type, dynamic_extent> first(index_type count) const + { + Expects(count >= 0 && count <= size()); + return {data(), count}; + } + + constexpr span<element_type, dynamic_extent> last(index_type count) const + { + Expects(count >= 0 && count <= size()); + return {data() + (size() - count), count}; + } + + constexpr span<element_type, dynamic_extent> subspan(index_type offset, + index_type count = dynamic_extent) const + { + Expects((offset == 0 || (offset > 0 && offset <= size())) && + (count == dynamic_extent || (count >= 0 && offset + count <= size()))); + return {data() + offset, count == dynamic_extent ? size() - offset : count}; + } + + // [span.obs], span observers + constexpr index_type length() const noexcept { return size(); } + constexpr index_type size() const noexcept { return storage_.size(); } + constexpr index_type length_bytes() const noexcept { return size_bytes(); } + constexpr index_type size_bytes() const noexcept { return size() * sizeof(element_type); } + constexpr bool empty() const noexcept { return size() == 0; } + + // [span.elem], span element access + constexpr reference operator[](index_type idx) const + { + Expects(idx >= 0 && idx < storage_.size()); + return data()[idx]; + } + + constexpr reference at(index_type idx) const { return this->operator[](idx); } + constexpr reference operator()(index_type idx) const { return this->operator[](idx); } + constexpr pointer data() const noexcept { return storage_.data(); } + + // [span.iter], span iterator support + iterator begin() const noexcept { return {this, 0}; } + iterator end() const noexcept { return {this, length()}; } + + const_iterator cbegin() const noexcept { return {this, 0}; } + const_iterator cend() const noexcept { return {this, length()}; } + + reverse_iterator rbegin() const noexcept { return reverse_iterator{end()}; } + reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; } + + const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator{cend()}; } + const_reverse_iterator crend() const noexcept { return const_reverse_iterator{cbegin()}; } + +private: + // this implementation detail class lets us take advantage of the + // empty base class optimization to pay for only storage of a single + // pointer in the case of fixed-size spans + template <class ExtentType> + class storage_type : public ExtentType + { + public: + template <class OtherExtentType> + constexpr storage_type(pointer data, OtherExtentType ext) : ExtentType(ext), data_(data) + { + Expects((!data && ExtentType::size() == 0) || (data && ExtentType::size() >= 0)); + } + + constexpr inline pointer data() const noexcept { return data_; } + + private: + pointer data_; + }; + + storage_type<details::extent_type<Extent>> storage_; +}; + +// [span.comparison], span comparison operators +template <class ElementType, std::ptrdiff_t FirstExtent, std::ptrdiff_t SecondExtent> +constexpr bool operator==(const span<ElementType, FirstExtent>& l, + const span<ElementType, SecondExtent>& r) +{ +#ifdef GSL_MSVC_NO_CPP14_STD_EQUAL + return (l.size() == r.size()) && std::equal(l.begin(), l.end(), r.begin()); +#else + return std::equal(l.begin(), l.end(), r.begin(), r.end()); +#endif +} + +template <class ElementType, std::ptrdiff_t Extent> +constexpr bool operator!=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) +{ + return !(l == r); +} + +template <class ElementType, std::ptrdiff_t Extent> +constexpr bool operator<(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) +{ + return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end()); +} + +template <class ElementType, std::ptrdiff_t Extent> +constexpr bool operator<=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) +{ + return !(l > r); +} + +template <class ElementType, std::ptrdiff_t Extent> +constexpr bool operator>(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) +{ + return r < l; +} + +template <class ElementType, std::ptrdiff_t Extent> +constexpr bool operator>=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) +{ + return !(l < r); +} + +namespace details +{ + // if we only supported compilers with good constexpr support then + // this pair of classes could collapse down to a constexpr function + + // we should use a narrow_cast<> to go to size_t, but older compilers may not see it as + // constexpr + // and so will fail compilation of the template + template <class ElementType, std::ptrdiff_t Extent> + struct calculate_byte_size + : std::integral_constant<std::ptrdiff_t, + static_cast<std::ptrdiff_t>(sizeof(ElementType) * + static_cast<std::size_t>(Extent))> + { + }; + + template <class ElementType> + struct calculate_byte_size<ElementType, dynamic_extent> + : std::integral_constant<std::ptrdiff_t, dynamic_extent> + { + }; +} + +// [span.objectrep], views of object representation +template <class ElementType, std::ptrdiff_t Extent> +span<const byte, details::calculate_byte_size<ElementType, Extent>::value> +as_bytes(span<ElementType, Extent> s) noexcept +{ + return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()}; +} + +template <class ElementType, std::ptrdiff_t Extent, + class = std::enable_if_t<!std::is_const<ElementType>::value>> +span<byte, details::calculate_byte_size<ElementType, Extent>::value> +as_writeable_bytes(span<ElementType, Extent> s) noexcept +{ + return {reinterpret_cast<byte*>(s.data()), s.size_bytes()}; +} + +// Specialization of gsl::at for span +template <class ElementType, std::ptrdiff_t Extent> +constexpr ElementType& at(const span<ElementType, Extent>& s, size_t index) +{ + // No bounds checking here because it is done in span::operator[] called below + return s[index]; +} + +} // namespace gsl + +#ifdef _MSC_VER + +#undef constexpr +#pragma pop_macro("constexpr") + +#if _MSC_VER <= 1800 +#pragma warning(pop) + +#ifndef GSL_THROW_ON_CONTRACT_VIOLATION +#undef noexcept +#pragma pop_macro("noexcept") +#endif // GSL_THROW_ON_CONTRACT_VIOLATION + +#pragma pop_macro("alignof") + +#undef GSL_MSVC_HAS_VARIADIC_CTOR_BUG + +#endif // _MSC_VER <= 1800 + +#endif // _MSC_VER + +#if defined(GSL_THROW_ON_CONTRACT_VIOLATION) + +#undef noexcept + +#ifdef _MSC_VER +#pragma pop_macro("noexcept") +#endif + +#endif // GSL_THROW_ON_CONTRACT_VIOLATION + +#ifdef _MSC_VER +#pragma warning(pop) +#endif + +#endif // GSL_SPAN_H |