para/GSL
1
0
Fork 0
mirror of https://github.com/microsoft/GSL.git synced 2024-11-03 17:56:43 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Renaming array_view and string_view, as per WG21 discussions.

Browse Source
This commit is contained in:
Neil MacIntosh 2015-11-04 12:42:27 -08:00
parent 54f832115b
commit b63ec949e9
7 changed files with 495 additions and 498 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/gsl.h
View File

@ -19,8 +19,8 @@
#ifndef GSL_GSL_H #ifndef GSL_GSL_H
#define GSL_GSL_H #define GSL_GSL_H
#include "array_view.h" // array_view, strided_array_view... #include "span.h" // span, strided_span...
#include "string_view.h" // zstring, string_view, zstring_builder... #include "string_span.h" // zstring, string_span, zstring_builder...
#include <memory> #include <memory>
#ifdef _MSC_VER #ifdef _MSC_VER

290
include/array_view.h → include/span.h
View File

@ -16,8 +16,8 @@
#pragma once #pragma once
#ifndef GSL_ARRAY_VIEW_H #ifndef GSL_SPAN_H
#define GSL_ARRAY_VIEW_H #define GSL_SPAN_H
#include <new> #include <new>
#include <stdexcept> #include <stdexcept>
@ -998,7 +998,7 @@ bounds_iterator<IndexType> operator+(typename bounds_iterator<IndexType>::differ
} }
// //
// begin definitions of basic_array_view // begin definitions of basic_span
// //
namespace details namespace details
{ {
@ -1036,13 +1036,13 @@ namespace details
} // namespace details } // namespace details
template <typename ArrayView> template <typename ArrayView>
class contiguous_array_view_iterator; class contiguous_span_iterator;
template <typename ArrayView> template <typename ArrayView>
class general_array_view_iterator; class general_span_iterator;
enum class byte : std::uint8_t {}; enum class byte : std::uint8_t {};
template <typename ValueType, typename BoundsType> template <typename ValueType, typename BoundsType>
class basic_array_view class basic_span
{ {
public: public:
static const size_t rank = BoundsType::rank; static const size_t rank = BoundsType::rank;
@ -1053,11 +1053,11 @@ public:
using const_value_type = std::add_const_t<value_type>; using const_value_type = std::add_const_t<value_type>;
using pointer = ValueType*; using pointer = ValueType*;
using reference = ValueType&; using reference = ValueType&;
using iterator = std::conditional_t<std::is_same<typename BoundsType::mapping_type, contiguous_mapping_tag>::value, contiguous_array_view_iterator<basic_array_view>, general_array_view_iterator<basic_array_view>>; using iterator = std::conditional_t<std::is_same<typename BoundsType::mapping_type, contiguous_mapping_tag>::value, contiguous_span_iterator<basic_span>, general_span_iterator<basic_span>>;
using const_iterator = std::conditional_t<std::is_same<typename BoundsType::mapping_type, contiguous_mapping_tag>::value, contiguous_array_view_iterator<basic_array_view<const_value_type, BoundsType>>, general_array_view_iterator<basic_array_view<const_value_type, BoundsType>>>; using const_iterator = std::conditional_t<std::is_same<typename BoundsType::mapping_type, contiguous_mapping_tag>::value, contiguous_span_iterator<basic_span<const_value_type, BoundsType>>, general_span_iterator<basic_span<const_value_type, BoundsType>>>;
using reverse_iterator = std::reverse_iterator<iterator>; using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>; using const_reverse_iterator = std::reverse_iterator<const_iterator>;
using sliced_type = std::conditional_t<rank == 1, value_type, basic_array_view<value_type, typename BoundsType::sliced_type>>; using sliced_type = std::conditional_t<rank == 1, value_type, basic_span<value_type, typename BoundsType::sliced_type>>;
private: private:
pointer m_pdata; pointer m_pdata;
@ -1111,11 +1111,11 @@ public:
} }
constexpr const_iterator cbegin() const constexpr const_iterator cbegin() const
{ {
return const_iterator {reinterpret_cast<const basic_array_view<const value_type, bounds_type> *>(this), true}; return const_iterator {reinterpret_cast<const basic_span<const value_type, bounds_type> *>(this), true};
} }
constexpr const_iterator cend() const constexpr const_iterator cend() const
{ {
return const_iterator {reinterpret_cast<const basic_array_view<const value_type, bounds_type> *>(this), false}; return const_iterator {reinterpret_cast<const basic_span<const value_type, bounds_type> *>(this), false};
} }
constexpr reverse_iterator rbegin() const constexpr reverse_iterator rbegin() const
@ -1136,38 +1136,38 @@ public:
} }
template <typename OtherValueType, typename OtherBoundsType, typename Dummy = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> template <typename OtherValueType, typename OtherBoundsType, typename Dummy = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
constexpr bool operator== (const basic_array_view<OtherValueType, OtherBoundsType> & other) const noexcept constexpr bool operator== (const basic_span<OtherValueType, OtherBoundsType> & other) const noexcept
{ {
return m_bounds.size() == other.m_bounds.size() && return m_bounds.size() == other.m_bounds.size() &&
(m_pdata == other.m_pdata || std::equal(this->begin(), this->end(), other.begin())); (m_pdata == other.m_pdata || std::equal(this->begin(), this->end(), other.begin()));
} }
template <typename OtherValueType, typename OtherBoundsType, typename Dummy = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> template <typename OtherValueType, typename OtherBoundsType, typename Dummy = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
constexpr bool operator!= (const basic_array_view<OtherValueType, OtherBoundsType> & other) const noexcept constexpr bool operator!= (const basic_span<OtherValueType, OtherBoundsType> & other) const noexcept
{ {
return !(*this == other); return !(*this == other);
} }
template <typename OtherValueType, typename OtherBoundsType, typename Dummy = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> template <typename OtherValueType, typename OtherBoundsType, typename Dummy = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
constexpr bool operator< (const basic_array_view<OtherValueType, OtherBoundsType> & other) const noexcept constexpr bool operator< (const basic_span<OtherValueType, OtherBoundsType> & other) const noexcept
{ {
return std::lexicographical_compare(this->begin(), this->end(), other.begin(), other.end()); return std::lexicographical_compare(this->begin(), this->end(), other.begin(), other.end());
} }
template <typename OtherValueType, typename OtherBoundsType, typename Dummy = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> template <typename OtherValueType, typename OtherBoundsType, typename Dummy = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
constexpr bool operator<= (const basic_array_view<OtherValueType, OtherBoundsType> & other) const noexcept constexpr bool operator<= (const basic_span<OtherValueType, OtherBoundsType> & other) const noexcept
{ {
return !(other < *this); return !(other < *this);
} }
template <typename OtherValueType, typename OtherBoundsType, typename Dummy = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> template <typename OtherValueType, typename OtherBoundsType, typename Dummy = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
constexpr bool operator> (const basic_array_view<OtherValueType, OtherBoundsType> & other) const noexcept constexpr bool operator> (const basic_span<OtherValueType, OtherBoundsType> & other) const noexcept
{ {
return (other < *this); return (other < *this);
} }
template <typename OtherValueType, typename OtherBoundsType, typename Dummy = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> template <typename OtherValueType, typename OtherBoundsType, typename Dummy = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>>
constexpr bool operator>= (const basic_array_view<OtherValueType, OtherBoundsType> & other) const noexcept constexpr bool operator>= (const basic_span<OtherValueType, OtherBoundsType> & other) const noexcept
{ {
return !(*this < other); return !(*this < other);
} }
@ -1176,27 +1176,27 @@ public:
template <typename OtherValueType, typename OtherBounds, template <typename OtherValueType, typename OtherBounds,
typename Dummy = std::enable_if_t<std::is_convertible<OtherValueType(*)[], value_type(*)[]>::value typename Dummy = std::enable_if_t<std::is_convertible<OtherValueType(*)[], value_type(*)[]>::value
&& std::is_convertible<OtherBounds, bounds_type>::value>> && std::is_convertible<OtherBounds, bounds_type>::value>>
constexpr basic_array_view(const basic_array_view<OtherValueType, OtherBounds> & other ) noexcept constexpr basic_span(const basic_span<OtherValueType, OtherBounds> & other ) noexcept
: m_pdata(other.m_pdata), m_bounds(other.m_bounds) : m_pdata(other.m_pdata), m_bounds(other.m_bounds)
{ {
} }
protected: protected:
constexpr basic_array_view(pointer data, bounds_type bound) noexcept constexpr basic_span(pointer data, bounds_type bound) noexcept
: m_pdata(data) : m_pdata(data)
, m_bounds(std::move(bound)) , m_bounds(std::move(bound))
{ {
fail_fast_assert((m_bounds.size() > 0 && data != nullptr) || m_bounds.size() == 0); fail_fast_assert((m_bounds.size() > 0 && data != nullptr) || m_bounds.size() == 0);
} }
template <typename T> template <typename T>
constexpr basic_array_view(T *data, std::enable_if_t<std::is_same<value_type, std::remove_all_extents_t<T>>::value, bounds_type> bound) noexcept constexpr basic_span(T *data, std::enable_if_t<std::is_same<value_type, std::remove_all_extents_t<T>>::value, bounds_type> bound) noexcept
: m_pdata(reinterpret_cast<pointer>(data)) : m_pdata(reinterpret_cast<pointer>(data))
, m_bounds(std::move(bound)) , m_bounds(std::move(bound))
{ {
fail_fast_assert((m_bounds.size() > 0 && data != nullptr) || m_bounds.size() == 0); fail_fast_assert((m_bounds.size() > 0 && data != nullptr) || m_bounds.size() == 0);
} }
template <typename DestBounds> template <typename DestBounds>
constexpr basic_array_view<value_type, DestBounds> as_array_view(const DestBounds &bounds) constexpr basic_span<value_type, DestBounds> as_span(const DestBounds &bounds)
{ {
details::verifyBoundsReshape(m_bounds, bounds); details::verifyBoundsReshape(m_bounds, bounds);
return {m_pdata, bounds}; return {m_pdata, bounds};
@ -1206,7 +1206,7 @@ private:
friend iterator; friend iterator;
friend const_iterator; friend const_iterator;
template <typename ValueType2, typename BoundsType2> template <typename ValueType2, typename BoundsType2>
friend class basic_array_view; friend class basic_span;
}; };
template <std::ptrdiff_t DimSize = dynamic_range> template <std::ptrdiff_t DimSize = dynamic_range>
@ -1223,10 +1223,10 @@ struct dim<dynamic_range>
}; };
template <typename ValueType, std::ptrdiff_t FirstDimension = dynamic_range, std::ptrdiff_t... RestDimensions> template <typename ValueType, std::ptrdiff_t FirstDimension = dynamic_range, std::ptrdiff_t... RestDimensions>
class array_view; class span;
template <typename ValueType, size_t Rank> template <typename ValueType, size_t Rank>
class strided_array_view; class strided_span;
namespace details namespace details
{ {
@ -1238,15 +1238,15 @@ namespace details
}; };
template <typename Traits> template <typename Traits>
struct ArrayViewTypeTraits<Traits, typename std::is_reference<typename Traits::array_view_traits &>::type> struct ArrayViewTypeTraits<Traits, typename std::is_reference<typename Traits::span_traits &>::type>
{ {
using value_type = typename Traits::array_view_traits::value_type; using value_type = typename Traits::span_traits::value_type;
using size_type = typename Traits::array_view_traits::size_type; using size_type = typename Traits::span_traits::size_type;
}; };
template <typename T, std::ptrdiff_t... Ranks> template <typename T, std::ptrdiff_t... Ranks>
struct ArrayViewArrayTraits { struct ArrayViewArrayTraits {
using type = array_view<T, Ranks...>; using type = span<T, Ranks...>;
using value_type = T; using value_type = T;
using bounds_type = static_bounds<Ranks...>; using bounds_type = static_bounds<Ranks...>;
using pointer = T*; using pointer = T*;
@ -1277,54 +1277,54 @@ namespace details
struct Sep{}; struct Sep{};
template <typename T, typename... Args> template <typename T, typename... Args>
T static_as_array_view_helper(Sep, Args... args) T static_as_span_helper(Sep, Args... args)
{ {
return T{static_cast<typename T::size_type>(args)...}; return T{static_cast<typename T::size_type>(args)...};
} }
template <typename T, typename Arg, typename... Args> template <typename T, typename Arg, typename... Args>
std::enable_if_t<!std::is_same<Arg, dim<dynamic_range>>::value && !std::is_same<Arg, Sep>::value, T> static_as_array_view_helper(Arg, Args... args) std::enable_if_t<!std::is_same<Arg, dim<dynamic_range>>::value && !std::is_same<Arg, Sep>::value, T> static_as_span_helper(Arg, Args... args)
{ {
return static_as_array_view_helper<T>(args...); return static_as_span_helper<T>(args...);
} }
template <typename T, typename... Args> template <typename T, typename... Args>
T static_as_array_view_helper(dim<dynamic_range> val, Args ... args) T static_as_span_helper(dim<dynamic_range> val, Args ... args)
{ {
return static_as_array_view_helper<T>(args..., val.dvalue); return static_as_span_helper<T>(args..., val.dvalue);
} }
template <typename ...Dimensions> template <typename ...Dimensions>
struct static_as_array_view_static_bounds_helper struct static_as_span_static_bounds_helper
{ {
using type = static_bounds<(Dimensions::value)...>; using type = static_bounds<(Dimensions::value)...>;
}; };
template <typename T> template <typename T>
struct is_array_view_oracle : std::false_type struct is_span_oracle : std::false_type
{}; {};
template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions> template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions>
struct is_array_view_oracle<array_view<ValueType, FirstDimension, RestDimensions...>> : std::true_type struct is_span_oracle<span<ValueType, FirstDimension, RestDimensions...>> : std::true_type
{}; {};
template <typename ValueType, std::ptrdiff_t Rank> template <typename ValueType, std::ptrdiff_t Rank>
struct is_array_view_oracle<strided_array_view<ValueType, Rank>> : std::true_type struct is_span_oracle<strided_span<ValueType, Rank>> : std::true_type
{}; {};
template <typename T> template <typename T>
struct is_array_view : is_array_view_oracle<std::remove_cv_t<T>> struct is_span : is_span_oracle<std::remove_cv_t<T>>
{}; {};
} }
template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions> template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions>
class array_view : public basic_array_view <ValueType, static_bounds <FirstDimension, RestDimensions...>> class span : public basic_span <ValueType, static_bounds <FirstDimension, RestDimensions...>>
{ {
template <typename ValueType2, std::ptrdiff_t FirstDimension2, template <typename ValueType2, std::ptrdiff_t FirstDimension2,
std::ptrdiff_t... RestDimensions2> std::ptrdiff_t... RestDimensions2>
friend class array_view; friend class span;
using Base = basic_array_view<ValueType, static_bounds<FirstDimension, RestDimensions...>>; using Base = basic_span<ValueType, static_bounds<FirstDimension, RestDimensions...>>;
public: public:
using typename Base::bounds_type; using typename Base::bounds_type;
@ -1339,42 +1339,42 @@ public:
public: public:
// basic // basic
constexpr array_view(pointer ptr, size_type size) : Base(ptr, bounds_type{ size }) constexpr span(pointer ptr, size_type size) : Base(ptr, bounds_type{ size })
{} {}
constexpr array_view(pointer ptr, bounds_type bounds) : Base(ptr, std::move(bounds)) constexpr span(pointer ptr, bounds_type bounds) : Base(ptr, std::move(bounds))
{} {}
constexpr array_view(std::nullptr_t) : Base(nullptr, bounds_type{}) constexpr span(std::nullptr_t) : Base(nullptr, bounds_type{})
{} {}
constexpr array_view(std::nullptr_t, size_type size) : Base(nullptr, bounds_type{}) constexpr span(std::nullptr_t, size_type size) : Base(nullptr, bounds_type{})
{ {
fail_fast_assert(size == 0); fail_fast_assert(size == 0);
} }
// default // default
template <std::ptrdiff_t DynamicRank = bounds_type::dynamic_rank, typename = std::enable_if_t<DynamicRank != 0>> template <std::ptrdiff_t DynamicRank = bounds_type::dynamic_rank, typename = std::enable_if_t<DynamicRank != 0>>
constexpr array_view() : Base(nullptr, bounds_type()) constexpr span() : Base(nullptr, bounds_type())
{} {}
// from n-dimensions dynamic array (e.g. new int[m][4]) (precedence will be lower than the 1-dimension pointer) // from n-dimensions dynamic array (e.g. new int[m][4]) (precedence will be lower than the 1-dimension pointer)
template <typename T, typename Helper = details::ArrayViewArrayTraits<T, dynamic_range> template <typename T, typename Helper = details::ArrayViewArrayTraits<T, dynamic_range>
/*typename Dummy = std::enable_if_t<std::is_convertible<Helper::value_type (*)[], typename Base::value_type (*)[]>::value>*/> /*typename Dummy = std::enable_if_t<std::is_convertible<Helper::value_type (*)[], typename Base::value_type (*)[]>::value>*/>
constexpr array_view(T* const& data, size_type size) : Base(data, typename Helper::bounds_type{size}) constexpr span(T* const& data, size_type size) : Base(data, typename Helper::bounds_type{size})
{} {}
// from n-dimensions static array // from n-dimensions static array
template <typename T, size_t N, typename Helper = details::ArrayViewArrayTraits<T, N>, template <typename T, size_t N, typename Helper = details::ArrayViewArrayTraits<T, N>,
typename = std::enable_if_t<std::is_convertible<typename Helper::value_type(*)[], typename Base::value_type(*)[]>::value>> typename = std::enable_if_t<std::is_convertible<typename Helper::value_type(*)[], typename Base::value_type(*)[]>::value>>
constexpr array_view (T (&arr)[N]) : Base(arr, typename Helper::bounds_type()) constexpr span (T (&arr)[N]) : Base(arr, typename Helper::bounds_type())
{} {}
// from n-dimensions static array with size // from n-dimensions static array with size
template <typename T, size_t N, typename Helper = details::ArrayViewArrayTraits<T, N>, template <typename T, size_t N, typename Helper = details::ArrayViewArrayTraits<T, N>,
typename = std::enable_if_t<std::is_convertible<typename Helper::value_type(*)[], typename Base::value_type(*)[]>::value> typename = std::enable_if_t<std::is_convertible<typename Helper::value_type(*)[], typename Base::value_type(*)[]>::value>
> >
constexpr array_view(T(&arr)[N], size_type size) : Base(arr, typename Helper::bounds_type{size}) constexpr span(T(&arr)[N], size_type size) : Base(arr, typename Helper::bounds_type{size})
{ {
fail_fast_assert(size <= N); fail_fast_assert(size <= N);
} }
@ -1383,14 +1383,14 @@ public:
template <size_t N, template <size_t N,
typename Dummy = std::enable_if_t<std::is_convertible<static_bounds<N>, typename Base::bounds_type>::value> typename Dummy = std::enable_if_t<std::is_convertible<static_bounds<N>, typename Base::bounds_type>::value>
> >
constexpr array_view (std::array<std::remove_const_t<value_type>, N> & arr) : Base(arr.data(), static_bounds<N>()) constexpr span (std::array<std::remove_const_t<value_type>, N> & arr) : Base(arr.data(), static_bounds<N>())
{} {}
template <size_t N, template <size_t N,
typename Dummy = std::enable_if_t<std::is_convertible<static_bounds<N>, typename Base::bounds_type>::value typename Dummy = std::enable_if_t<std::is_convertible<static_bounds<N>, typename Base::bounds_type>::value
&& std::is_const<value_type>::value> && std::is_const<value_type>::value>
> >
constexpr array_view (const std::array<std::remove_const_t<value_type>, N> & arr) : Base(arr.data(), static_bounds<N>()) constexpr span (const std::array<std::remove_const_t<value_type>, N> & arr) : Base(arr.data(), static_bounds<N>())
{} {}
// from begin, end pointers. We don't provide iterator pair since no way to guarantee the contiguity // from begin, end pointers. We don't provide iterator pair since no way to guarantee the contiguity
@ -1398,59 +1398,59 @@ public:
typename Dummy = std::enable_if_t<std::is_convertible<Ptr, pointer>::value typename Dummy = std::enable_if_t<std::is_convertible<Ptr, pointer>::value
&& details::LessThan<Base::bounds_type::dynamic_rank, 2>::value> && details::LessThan<Base::bounds_type::dynamic_rank, 2>::value>
> // remove literal 0 case > // remove literal 0 case
constexpr array_view (pointer begin, Ptr end) : Base(begin, details::newBoundsHelper<typename Base::bounds_type>(static_cast<pointer>(end) - begin)) constexpr span (pointer begin, Ptr end) : Base(begin, details::newBoundsHelper<typename Base::bounds_type>(static_cast<pointer>(end) - begin))
{} {}
// from containers. It must has .size() and .data() two function signatures // from containers. It must has .size() and .data() two function signatures
template <typename Cont, typename DataType = typename Cont::value_type, template <typename Cont, typename DataType = typename Cont::value_type,
typename Dummy = std::enable_if_t<!details::is_array_view<Cont>::value typename Dummy = std::enable_if_t<!details::is_span<Cont>::value
&& std::is_convertible<DataType (*)[], typename Base::value_type (*)[]>::value && std::is_convertible<DataType (*)[], typename Base::value_type (*)[]>::value
&& std::is_same<std::decay_t<decltype(std::declval<Cont>().size(), *std::declval<Cont>().data())>, DataType>::value> && std::is_same<std::decay_t<decltype(std::declval<Cont>().size(), *std::declval<Cont>().data())>, DataType>::value>
> >
constexpr array_view (Cont& cont) : Base(static_cast<pointer>(cont.data()), details::newBoundsHelper<typename Base::bounds_type>(cont.size())) constexpr span (Cont& cont) : Base(static_cast<pointer>(cont.data()), details::newBoundsHelper<typename Base::bounds_type>(cont.size()))
{} {}
constexpr array_view(const array_view &) = default; constexpr span(const span &) = default;
// convertible // convertible
template <typename OtherValueType, std::ptrdiff_t... OtherDimensions, template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
typename BaseType = basic_array_view<ValueType, static_bounds<FirstDimension, RestDimensions...>>, typename BaseType = basic_span<ValueType, static_bounds<FirstDimension, RestDimensions...>>,
typename OtherBaseType = basic_array_view<OtherValueType, static_bounds<OtherDimensions...>>, typename OtherBaseType = basic_span<OtherValueType, static_bounds<OtherDimensions...>>,
typename Dummy = std::enable_if_t<std::is_convertible<OtherBaseType, BaseType>::value> typename Dummy = std::enable_if_t<std::is_convertible<OtherBaseType, BaseType>::value>
> >
constexpr array_view(const array_view<OtherValueType, OtherDimensions...> &av) constexpr span(const span<OtherValueType, OtherDimensions...> &av)
: Base(static_cast<const typename array_view<OtherValueType, OtherDimensions...>::Base&>(av)) : Base(static_cast<const typename span<OtherValueType, OtherDimensions...>::Base&>(av))
{} {}
// reshape // reshape
// DimCount here is a workaround for a bug in MSVC 2015 // DimCount here is a workaround for a bug in MSVC 2015
template <typename... Dimensions2, size_t DimCount = sizeof...(Dimensions2), typename = std::enable_if_t<(DimCount > 0)>> template <typename... Dimensions2, size_t DimCount = sizeof...(Dimensions2), typename = std::enable_if_t<(DimCount > 0)>>
constexpr array_view<ValueType, Dimensions2::value...> as_array_view(Dimensions2... dims) constexpr span<ValueType, Dimensions2::value...> as_span(Dimensions2... dims)
{ {
using BoundsType = typename array_view<ValueType, (Dimensions2::value)...>::bounds_type; using BoundsType = typename span<ValueType, (Dimensions2::value)...>::bounds_type;
auto tobounds = details::static_as_array_view_helper<BoundsType>(dims..., details::Sep{}); auto tobounds = details::static_as_span_helper<BoundsType>(dims..., details::Sep{});
details::verifyBoundsReshape(this->bounds(), tobounds); details::verifyBoundsReshape(this->bounds(), tobounds);
return {this->data(), tobounds}; return {this->data(), tobounds};
} }
// to bytes array // to bytes array
template <bool Enabled = std::is_standard_layout<std::decay_t<ValueType>>::value> template <bool Enabled = std::is_standard_layout<std::decay_t<ValueType>>::value>
auto as_bytes() const noexcept -> array_view<const byte> auto as_bytes() const noexcept -> span<const byte>
{ {
static_assert(Enabled, "The value_type of array_view must be standarded layout"); static_assert(Enabled, "The value_type of span must be standarded layout");
return { reinterpret_cast<const byte*>(this->data()), this->bytes() }; return { reinterpret_cast<const byte*>(this->data()), this->bytes() };
} }
template <bool Enabled = std::is_standard_layout<std::decay_t<ValueType>>::value> template <bool Enabled = std::is_standard_layout<std::decay_t<ValueType>>::value>
auto as_writeable_bytes() const noexcept -> array_view<byte> auto as_writeable_bytes() const noexcept -> span<byte>
{ {
static_assert(Enabled, "The value_type of array_view must be standarded layout"); static_assert(Enabled, "The value_type of span must be standarded layout");
return { reinterpret_cast<byte*>(this->data()), this->bytes() }; return { reinterpret_cast<byte*>(this->data()), this->bytes() };
} }
// from bytes array // from bytes array
template<typename U, bool IsByte = std::is_same<value_type, const byte>::value, typename = std::enable_if_t<IsByte && sizeof...(RestDimensions) == 0>> template<typename U, bool IsByte = std::is_same<value_type, const byte>::value, typename = std::enable_if_t<IsByte && sizeof...(RestDimensions) == 0>>
constexpr auto as_array_view() const noexcept -> array_view<const U, (Base::bounds_type::static_size != dynamic_range ? static_cast<std::ptrdiff_t>(static_cast<size_t>(Base::bounds_type::static_size) / sizeof(U)) : dynamic_range)> constexpr auto as_span() const noexcept -> span<const U, (Base::bounds_type::static_size != dynamic_range ? static_cast<std::ptrdiff_t>(static_cast<size_t>(Base::bounds_type::static_size) / sizeof(U)) : dynamic_range)>
{ {
static_assert(std::is_standard_layout<U>::value && (Base::bounds_type::static_size == dynamic_range || Base::bounds_type::static_size % static_cast<size_type>(sizeof(U)) == 0), static_assert(std::is_standard_layout<U>::value && (Base::bounds_type::static_size == dynamic_range || Base::bounds_type::static_size % static_cast<size_type>(sizeof(U)) == 0),
"Target type must be standard layout and its size must match the byte array size"); "Target type must be standard layout and its size must match the byte array size");
@ -1459,7 +1459,7 @@ public:
} }
template<typename U, bool IsByte = std::is_same<value_type, byte>::value, typename = std::enable_if_t<IsByte && sizeof...(RestDimensions) == 0>> template<typename U, bool IsByte = std::is_same<value_type, byte>::value, typename = std::enable_if_t<IsByte && sizeof...(RestDimensions) == 0>>
constexpr auto as_array_view() const noexcept -> array_view<U, (Base::bounds_type::static_size != dynamic_range ? static_cast<ptrdiff_t>(static_cast<size_t>(Base::bounds_type::static_size) / sizeof(U)) : dynamic_range)> constexpr auto as_span() const noexcept -> span<U, (Base::bounds_type::static_size != dynamic_range ? static_cast<ptrdiff_t>(static_cast<size_t>(Base::bounds_type::static_size) / sizeof(U)) : dynamic_range)>
{ {
static_assert(std::is_standard_layout<U>::value && (Base::bounds_type::static_size == dynamic_range || Base::bounds_type::static_size % static_cast<size_t>(sizeof(U)) == 0), static_assert(std::is_standard_layout<U>::value && (Base::bounds_type::static_size == dynamic_range || Base::bounds_type::static_size % static_cast<size_t>(sizeof(U)) == 0),
"Target type must be standard layout and its size must match the byte array size"); "Target type must be standard layout and its size must match the byte array size");
@ -1469,42 +1469,42 @@ public:
// section on linear space // section on linear space
template<std::ptrdiff_t Count> template<std::ptrdiff_t Count>
constexpr array_view<ValueType, Count> first() const noexcept constexpr span<ValueType, Count> first() const noexcept
{ {
static_assert(bounds_type::static_size == dynamic_range || Count <= bounds_type::static_size, "Index is out of bound"); static_assert(bounds_type::static_size == dynamic_range || Count <= bounds_type::static_size, "Index is out of bound");
fail_fast_assert(bounds_type::static_size != dynamic_range || Count <= this->size()); // ensures we only check condition when needed fail_fast_assert(bounds_type::static_size != dynamic_range || Count <= this->size()); // ensures we only check condition when needed
return { this->data(), Count }; return { this->data(), Count };
} }
constexpr array_view<ValueType, dynamic_range> first(size_type count) const noexcept constexpr span<ValueType, dynamic_range> first(size_type count) const noexcept
{ {
fail_fast_assert(count <= this->size()); fail_fast_assert(count <= this->size());
return { this->data(), count }; return { this->data(), count };
} }
template<std::ptrdiff_t Count> template<std::ptrdiff_t Count>
constexpr array_view<ValueType, Count> last() const noexcept constexpr span<ValueType, Count> last() const noexcept
{ {
static_assert(bounds_type::static_size == dynamic_range || Count <= bounds_type::static_size, "Index is out of bound"); static_assert(bounds_type::static_size == dynamic_range || Count <= bounds_type::static_size, "Index is out of bound");
fail_fast_assert(bounds_type::static_size != dynamic_range || Count <= this->size()); fail_fast_assert(bounds_type::static_size != dynamic_range || Count <= this->size());
return { this->data() + this->size() - Count, Count }; return { this->data() + this->size() - Count, Count };
} }
constexpr array_view<ValueType, dynamic_range> last(size_type count) const noexcept constexpr span<ValueType, dynamic_range> last(size_type count) const noexcept
{ {
fail_fast_assert(count <= this->size()); fail_fast_assert(count <= this->size());
return { this->data() + this->size() - count, count }; return { this->data() + this->size() - count, count };
} }
template<std::ptrdiff_t Offset, std::ptrdiff_t Count> template<std::ptrdiff_t Offset, std::ptrdiff_t Count>
constexpr array_view<ValueType, Count> sub() const noexcept constexpr span<ValueType, Count> sub() const noexcept
{ {
static_assert(bounds_type::static_size == dynamic_range || ((Offset == 0 || Offset <= bounds_type::static_size) && Offset + Count <= bounds_type::static_size), "Index is out of bound"); static_assert(bounds_type::static_size == dynamic_range || ((Offset == 0 || Offset <= bounds_type::static_size) && Offset + Count <= bounds_type::static_size), "Index is out of bound");
fail_fast_assert(bounds_type::static_size != dynamic_range || ((Offset == 0 || Offset <= this->size()) && Offset + Count <= this->size())); fail_fast_assert(bounds_type::static_size != dynamic_range || ((Offset == 0 || Offset <= this->size()) && Offset + Count <= this->size()));
return { this->data() + Offset, Count }; return { this->data() + Offset, Count };
} }
constexpr array_view<ValueType, dynamic_range> sub(size_type offset, size_type count = dynamic_range) const noexcept constexpr span<ValueType, dynamic_range> sub(size_type offset, size_type count = dynamic_range) const noexcept
{ {
fail_fast_assert((offset == 0 || offset <= this->size()) && (count == dynamic_range || (offset + count) <= this->size())); fail_fast_assert((offset == 0 || offset <= this->size()) && (count == dynamic_range || (offset + count) <= this->size()));
return { this->data() + offset, count == dynamic_range ? this->length() - offset : count }; return { this->data() + offset, count == dynamic_range ? this->length() - offset : count };
@ -1532,7 +1532,7 @@ public:
} }
// section // section
constexpr strided_array_view<ValueType, rank> section(index_type origin, index_type extents) const constexpr strided_span<ValueType, rank> section(index_type origin, index_type extents) const
{ {
size_type size = this->bounds().total_size() - this->bounds().linearize(origin); size_type size = this->bounds().total_size() - this->bounds().linearize(origin);
return{ &this->operator[](origin), size, strided_bounds<rank> {extents, details::make_stride(Base::bounds())} }; return{ &this->operator[](origin), size, strided_bounds<rank> {extents, details::make_stride(Base::bounds())} };
@ -1544,7 +1544,7 @@ public:
} }
template <bool Enabled = (rank > 1), typename Dummy = std::enable_if_t<Enabled>> template <bool Enabled = (rank > 1), typename Dummy = std::enable_if_t<Enabled>>
constexpr array_view<ValueType, RestDimensions...> operator[](size_type idx) const constexpr span<ValueType, RestDimensions...> operator[](size_type idx) const
{ {
auto ret = Base::operator[](idx); auto ret = Base::operator[](idx);
return{ ret.data(), ret.bounds() }; return{ ret.data(), ret.bounds() };
@ -1559,63 +1559,63 @@ public:
}; };
template <typename T, std::ptrdiff_t... Dimensions> template <typename T, std::ptrdiff_t... Dimensions>
constexpr auto as_array_view(T* const& ptr, dim<Dimensions>... args) -> array_view<std::remove_all_extents_t<T>, Dimensions...> constexpr auto as_span(T* const& ptr, dim<Dimensions>... args) -> span<std::remove_all_extents_t<T>, Dimensions...>
{ {
return {reinterpret_cast<std::remove_all_extents_t<T>*>(ptr), details::static_as_array_view_helper<static_bounds<Dimensions...>>(args..., details::Sep{})}; return {reinterpret_cast<std::remove_all_extents_t<T>*>(ptr), details::static_as_span_helper<static_bounds<Dimensions...>>(args..., details::Sep{})};
} }
template <typename T> template <typename T>
constexpr auto as_array_view (T* arr, std::ptrdiff_t len) -> typename details::ArrayViewArrayTraits<T, dynamic_range>::type constexpr auto as_span (T* arr, std::ptrdiff_t len) -> typename details::ArrayViewArrayTraits<T, dynamic_range>::type
{ {
return {reinterpret_cast<std::remove_all_extents_t<T>*>(arr), len}; return {reinterpret_cast<std::remove_all_extents_t<T>*>(arr), len};
} }
template <typename T, size_t N> template <typename T, size_t N>
constexpr auto as_array_view (T (&arr)[N]) -> typename details::ArrayViewArrayTraits<T, N>::type constexpr auto as_span (T (&arr)[N]) -> typename details::ArrayViewArrayTraits<T, N>::type
{ {
return {arr}; return {arr};
} }
template <typename T, size_t N> template <typename T, size_t N>
constexpr array_view<const T, N> as_array_view(const std::array<T, N> &arr) constexpr span<const T, N> as_span(const std::array<T, N> &arr)
{ {
return {arr}; return {arr};
} }
template <typename T, size_t N> template <typename T, size_t N>
constexpr array_view<const T, N> as_array_view(const std::array<T, N> &&) = delete; constexpr span<const T, N> as_span(const std::array<T, N> &&) = delete;
template <typename T, size_t N> template <typename T, size_t N>
constexpr array_view<T, N> as_array_view(std::array<T, N> &arr) constexpr span<T, N> as_span(std::array<T, N> &arr)
{ {
return {arr}; return {arr};
} }
template <typename T> template <typename T>
constexpr array_view<T, dynamic_range> as_array_view(T *begin, T *end) constexpr span<T, dynamic_range> as_span(T *begin, T *end)
{ {
return {begin, end}; return {begin, end};
} }
template <typename Cont> template <typename Cont>
constexpr auto as_array_view(Cont &arr) -> std::enable_if_t<!details::is_array_view<std::decay_t<Cont>>::value, constexpr auto as_span(Cont &arr) -> std::enable_if_t<!details::is_span<std::decay_t<Cont>>::value,
array_view<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>> span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>>
{ {
fail_fast_assert(arr.size() < PTRDIFF_MAX); fail_fast_assert(arr.size() < PTRDIFF_MAX);
return {arr.data(), static_cast<std::ptrdiff_t>(arr.size())}; return {arr.data(), static_cast<std::ptrdiff_t>(arr.size())};
} }
template <typename Cont> template <typename Cont>
constexpr auto as_array_view(Cont &&arr) -> std::enable_if_t<!details::is_array_view<std::decay_t<Cont>>::value, constexpr auto as_span(Cont &&arr) -> std::enable_if_t<!details::is_span<std::decay_t<Cont>>::value,
array_view<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>> = delete; span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>> = delete;
template <typename ValueType, size_t Rank> template <typename ValueType, size_t Rank>
class strided_array_view : public basic_array_view<ValueType, strided_bounds<Rank>> class strided_span : public basic_span<ValueType, strided_bounds<Rank>>
{ {
using Base = basic_array_view<ValueType, strided_bounds<Rank>>; using Base = basic_span<ValueType, strided_bounds<Rank>>;
template<typename OtherValue, size_t OtherRank> template<typename OtherValue, size_t OtherRank>
friend class strided_array_view; friend class strided_span;
public: public:
using Base::rank; using Base::rank;
@ -1630,36 +1630,36 @@ public:
// from static array of size N // from static array of size N
template<size_type N> template<size_type N>
strided_array_view(value_type(&values)[N], bounds_type bounds) : Base(values, std::move(bounds)) strided_span(value_type(&values)[N], bounds_type bounds) : Base(values, std::move(bounds))
{ {
fail_fast_assert(this->bounds().total_size() <= N, "Bounds cross data boundaries"); fail_fast_assert(this->bounds().total_size() <= N, "Bounds cross data boundaries");
} }
// from raw data // from raw data
strided_array_view(pointer ptr, size_type size, bounds_type bounds): Base(ptr, std::move(bounds)) strided_span(pointer ptr, size_type size, bounds_type bounds): Base(ptr, std::move(bounds))
{ {
fail_fast_assert(this->bounds().total_size() <= size, "Bounds cross data boundaries"); fail_fast_assert(this->bounds().total_size() <= size, "Bounds cross data boundaries");
} }
// from array view // from array view
template <std::ptrdiff_t... Dimensions, typename Dummy = std::enable_if<sizeof...(Dimensions) == Rank>> template <std::ptrdiff_t... Dimensions, typename Dummy = std::enable_if<sizeof...(Dimensions) == Rank>>
strided_array_view(array_view<ValueType, Dimensions...> av, bounds_type bounds) : Base(av.data(), std::move(bounds)) strided_span(span<ValueType, Dimensions...> av, bounds_type bounds) : Base(av.data(), std::move(bounds))
{ {
fail_fast_assert(this->bounds().total_size() <= av.bounds().total_size(), "Bounds cross data boundaries"); fail_fast_assert(this->bounds().total_size() <= av.bounds().total_size(), "Bounds cross data boundaries");
} }
// convertible // convertible
template <typename OtherValueType, template <typename OtherValueType,
typename BaseType = basic_array_view<ValueType, strided_bounds<Rank>>, typename BaseType = basic_span<ValueType, strided_bounds<Rank>>,
typename OtherBaseType = basic_array_view<OtherValueType, strided_bounds<Rank>>, typename OtherBaseType = basic_span<OtherValueType, strided_bounds<Rank>>,
typename Dummy = std::enable_if_t<std::is_convertible<OtherBaseType, BaseType>::value> typename Dummy = std::enable_if_t<std::is_convertible<OtherBaseType, BaseType>::value>
> >
constexpr strided_array_view(const strided_array_view<OtherValueType, Rank> &av) : Base(static_cast<const typename strided_array_view<OtherValueType, Rank>::Base &>(av)) // static_cast is required constexpr strided_span(const strided_span<OtherValueType, Rank> &av) : Base(static_cast<const typename strided_span<OtherValueType, Rank>::Base &>(av)) // static_cast is required
{} {}
// convert from bytes // convert from bytes
template <typename OtherValueType> template <typename OtherValueType>
strided_array_view<typename std::enable_if<std::is_same<value_type, const byte>::value, OtherValueType>::type, rank> as_strided_array_view() const strided_span<typename std::enable_if<std::is_same<value_type, const byte>::value, OtherValueType>::type, rank> as_strided_span() const
{ {
static_assert((sizeof(OtherValueType) >= sizeof(value_type)) && (sizeof(OtherValueType) % sizeof(value_type) == 0), "OtherValueType should have a size to contain a multiple of ValueTypes"); static_assert((sizeof(OtherValueType) >= sizeof(value_type)) && (sizeof(OtherValueType) % sizeof(value_type) == 0), "OtherValueType should have a size to contain a multiple of ValueTypes");
auto d = static_cast<size_type>(sizeof(OtherValueType) / sizeof(value_type)); auto d = static_cast<size_type>(sizeof(OtherValueType) / sizeof(value_type));
@ -1668,7 +1668,7 @@ public:
return{ (OtherValueType*)this->data(), size, bounds_type{ resize_extent(this->bounds().index_bounds(), d), resize_stride(this->bounds().strides(), d)} }; return{ (OtherValueType*)this->data(), size, bounds_type{ resize_extent(this->bounds().index_bounds(), d), resize_stride(this->bounds().strides(), d)} };
} }
strided_array_view section(index_type origin, index_type extents) const strided_span section(index_type origin, index_type extents) const
{ {
size_type size = this->bounds().total_size() - this->bounds().linearize(origin); size_type size = this->bounds().total_size() - this->bounds().linearize(origin);
return { &this->operator[](origin), size, bounds_type {extents, details::make_stride(Base::bounds())}}; return { &this->operator[](origin), size, bounds_type {extents, details::make_stride(Base::bounds())}};
@ -1680,7 +1680,7 @@ public:
} }
template <bool Enabled = (rank > 1), typename Dummy = std::enable_if_t<Enabled>> template <bool Enabled = (rank > 1), typename Dummy = std::enable_if_t<Enabled>>
constexpr strided_array_view<value_type, rank-1> operator[](size_type idx) const constexpr strided_span<value_type, rank-1> operator[](size_type idx) const
{ {
auto ret = Base::operator[](idx); auto ret = Base::operator[](idx);
return{ ret.data(), ret.bounds().total_size(), ret.bounds() }; return{ ret.data(), ret.bounds().total_size(), ret.bounds() };
@ -1722,7 +1722,7 @@ private:
}; };
template <typename ArrayView> template <typename ArrayView>
class contiguous_array_view_iterator : public std::iterator<std::random_access_iterator_tag, typename ArrayView::value_type> class contiguous_span_iterator : public std::iterator<std::random_access_iterator_tag, typename ArrayView::value_type>
{ {
using Base = std::iterator<std::random_access_iterator_tag, typename ArrayView::value_type>; using Base = std::iterator<std::random_access_iterator_tag, typename ArrayView::value_type>;
public: public:
@ -1732,7 +1732,7 @@ public:
private: private:
template <typename ValueType, typename Bounds> template <typename ValueType, typename Bounds>
friend class basic_array_view; friend class basic_span;
pointer m_pdata; pointer m_pdata;
const ArrayView * m_validator; const ArrayView * m_validator;
@ -1740,7 +1740,7 @@ private:
{ {
fail_fast_assert(m_pdata >= m_validator->m_pdata && m_pdata < m_validator->m_pdata + m_validator->size(), "iterator is out of range of the array"); fail_fast_assert(m_pdata >= m_validator->m_pdata && m_pdata < m_validator->m_pdata + m_validator->size(), "iterator is out of range of the array");
} }
contiguous_array_view_iterator (const ArrayView *container, bool isbegin) : contiguous_span_iterator (const ArrayView *container, bool isbegin) :
m_pdata(isbegin ? container->m_pdata : container->m_pdata + container->size()), m_validator(container) {} m_pdata(isbegin ? container->m_pdata : container->m_pdata + container->size()), m_validator(container) {}
public: public:
reference operator*() const noexcept reference operator*() const noexcept
@ -1753,48 +1753,48 @@ public:
validateThis(); validateThis();
return m_pdata; return m_pdata;
} }
contiguous_array_view_iterator& operator++() noexcept contiguous_span_iterator& operator++() noexcept
{ {
++m_pdata; ++m_pdata;
return *this; return *this;
} }
contiguous_array_view_iterator operator++(int)noexcept contiguous_span_iterator operator++(int)noexcept
{ {
auto ret = *this; auto ret = *this;
++(*this); ++(*this);
return ret; return ret;
} }
contiguous_array_view_iterator& operator--() noexcept contiguous_span_iterator& operator--() noexcept
{ {
--m_pdata; --m_pdata;
return *this; return *this;
} }
contiguous_array_view_iterator operator--(int)noexcept contiguous_span_iterator operator--(int)noexcept
{ {
auto ret = *this; auto ret = *this;
--(*this); --(*this);
return ret; return ret;
} }
contiguous_array_view_iterator operator+(difference_type n) const noexcept contiguous_span_iterator operator+(difference_type n) const noexcept
{ {
contiguous_array_view_iterator ret{ *this }; contiguous_span_iterator ret{ *this };
return ret += n; return ret += n;
} }
contiguous_array_view_iterator& operator+=(difference_type n) noexcept contiguous_span_iterator& operator+=(difference_type n) noexcept
{ {
m_pdata += n; m_pdata += n;
return *this; return *this;
} }
contiguous_array_view_iterator operator-(difference_type n) const noexcept contiguous_span_iterator operator-(difference_type n) const noexcept
{ {
contiguous_array_view_iterator ret{ *this }; contiguous_span_iterator ret{ *this };
return ret -= n; return ret -= n;
} }
contiguous_array_view_iterator& operator-=(difference_type n) noexcept contiguous_span_iterator& operator-=(difference_type n) noexcept
{ {
return *this += -n; return *this += -n;
} }
difference_type operator-(const contiguous_array_view_iterator& rhs) const noexcept difference_type operator-(const contiguous_span_iterator& rhs) const noexcept
{ {
fail_fast_assert(m_validator == rhs.m_validator); fail_fast_assert(m_validator == rhs.m_validator);
return m_pdata - rhs.m_pdata; return m_pdata - rhs.m_pdata;
@ -1803,33 +1803,33 @@ public:
{ {
return *(*this + n); return *(*this + n);
} }
bool operator==(const contiguous_array_view_iterator& rhs) const noexcept bool operator==(const contiguous_span_iterator& rhs) const noexcept
{ {
fail_fast_assert(m_validator == rhs.m_validator); fail_fast_assert(m_validator == rhs.m_validator);
return m_pdata == rhs.m_pdata; return m_pdata == rhs.m_pdata;
} }
bool operator!=(const contiguous_array_view_iterator& rhs) const noexcept bool operator!=(const contiguous_span_iterator& rhs) const noexcept
{ {
return !(*this == rhs); return !(*this == rhs);
} }
bool operator<(const contiguous_array_view_iterator& rhs) const noexcept bool operator<(const contiguous_span_iterator& rhs) const noexcept
{ {
fail_fast_assert(m_validator == rhs.m_validator); fail_fast_assert(m_validator == rhs.m_validator);
return m_pdata < rhs.m_pdata; return m_pdata < rhs.m_pdata;
} }
bool operator<=(const contiguous_array_view_iterator& rhs) const noexcept bool operator<=(const contiguous_span_iterator& rhs) const noexcept
{ {
return !(rhs < *this); return !(rhs < *this);
} }
bool operator>(const contiguous_array_view_iterator& rhs) const noexcept bool operator>(const contiguous_span_iterator& rhs) const noexcept
{ {
return rhs < *this; return rhs < *this;
} }
bool operator>=(const contiguous_array_view_iterator& rhs) const noexcept bool operator>=(const contiguous_span_iterator& rhs) const noexcept
{ {
return !(rhs > *this); return !(rhs > *this);
} }
void swap(contiguous_array_view_iterator& rhs) noexcept void swap(contiguous_span_iterator& rhs) noexcept
{ {
std::swap(m_pdata, rhs.m_pdata); std::swap(m_pdata, rhs.m_pdata);
std::swap(m_validator, rhs.m_validator); std::swap(m_validator, rhs.m_validator);
@ -1837,13 +1837,13 @@ public:
}; };
template <typename ArrayView> template <typename ArrayView>
contiguous_array_view_iterator<ArrayView> operator+(typename contiguous_array_view_iterator<ArrayView>::difference_type n, const contiguous_array_view_iterator<ArrayView>& rhs) noexcept contiguous_span_iterator<ArrayView> operator+(typename contiguous_span_iterator<ArrayView>::difference_type n, const contiguous_span_iterator<ArrayView>& rhs) noexcept
{ {
return rhs + n; return rhs + n;
} }
template <typename ArrayView> template <typename ArrayView>
class general_array_view_iterator : public std::iterator<std::random_access_iterator_tag, typename ArrayView::value_type> class general_span_iterator : public std::iterator<std::random_access_iterator_tag, typename ArrayView::value_type>
{ {
using Base = std::iterator<std::random_access_iterator_tag, typename ArrayView::value_type>; using Base = std::iterator<std::random_access_iterator_tag, typename ArrayView::value_type>;
public: public:
@ -1853,11 +1853,11 @@ public:
using typename Base::value_type; using typename Base::value_type;
private: private:
template <typename ValueType, typename Bounds> template <typename ValueType, typename Bounds>
friend class basic_array_view; friend class basic_span;
const ArrayView * m_container; const ArrayView * m_container;
typename ArrayView::bounds_type::iterator m_itr; typename ArrayView::bounds_type::iterator m_itr;
general_array_view_iterator(const ArrayView *container, bool isbegin) : general_span_iterator(const ArrayView *container, bool isbegin) :
m_container(container), m_itr(isbegin ? m_container->bounds().begin() : m_container->bounds().end()) m_container(container), m_itr(isbegin ? m_container->bounds().begin() : m_container->bounds().end())
{} {}
public: public:
@ -1869,48 +1869,48 @@ public:
{ {
return &(*m_container)[*m_itr]; return &(*m_container)[*m_itr];
} }
general_array_view_iterator& operator++() noexcept general_span_iterator& operator++() noexcept
{ {
++m_itr; ++m_itr;
return *this; return *this;
} }
general_array_view_iterator operator++(int)noexcept general_span_iterator operator++(int)noexcept
{ {
auto ret = *this; auto ret = *this;
++(*this); ++(*this);
return ret; return ret;
} }
general_array_view_iterator& operator--() noexcept general_span_iterator& operator--() noexcept
{ {
--m_itr; --m_itr;
return *this; return *this;
} }
general_array_view_iterator operator--(int)noexcept general_span_iterator operator--(int)noexcept
{ {
auto ret = *this; auto ret = *this;
--(*this); --(*this);
return ret; return ret;
} }
general_array_view_iterator operator+(difference_type n) const noexcept general_span_iterator operator+(difference_type n) const noexcept
{ {
general_array_view_iterator ret{ *this }; general_span_iterator ret{ *this };
return ret += n; return ret += n;
} }
general_array_view_iterator& operator+=(difference_type n) noexcept general_span_iterator& operator+=(difference_type n) noexcept
{ {
m_itr += n; m_itr += n;
return *this; return *this;
} }
general_array_view_iterator operator-(difference_type n) const noexcept general_span_iterator operator-(difference_type n) const noexcept
{ {
general_array_view_iterator ret{ *this }; general_span_iterator ret{ *this };
return ret -= n; return ret -= n;
} }
general_array_view_iterator& operator-=(difference_type n) noexcept general_span_iterator& operator-=(difference_type n) noexcept
{ {
return *this += -n; return *this += -n;
} }
difference_type operator-(const general_array_view_iterator& rhs) const noexcept difference_type operator-(const general_span_iterator& rhs) const noexcept
{ {
fail_fast_assert(m_container == rhs.m_container); fail_fast_assert(m_container == rhs.m_container);
return m_itr - rhs.m_itr; return m_itr - rhs.m_itr;
@ -1919,33 +1919,33 @@ public:
{ {
return (*m_container)[m_itr[n]];; return (*m_container)[m_itr[n]];;
} }
bool operator==(const general_array_view_iterator& rhs) const noexcept bool operator==(const general_span_iterator& rhs) const noexcept
{ {
fail_fast_assert(m_container == rhs.m_container); fail_fast_assert(m_container == rhs.m_container);
return m_itr == rhs.m_itr; return m_itr == rhs.m_itr;
} }
bool operator !=(const general_array_view_iterator& rhs) const noexcept bool operator !=(const general_span_iterator& rhs) const noexcept
{ {
return !(*this == rhs); return !(*this == rhs);
} }
bool operator<(const general_array_view_iterator& rhs) const noexcept bool operator<(const general_span_iterator& rhs) const noexcept
{ {
fail_fast_assert(m_container == rhs.m_container); fail_fast_assert(m_container == rhs.m_container);
return m_itr < rhs.m_itr; return m_itr < rhs.m_itr;
} }
bool operator<=(const general_array_view_iterator& rhs) const noexcept bool operator<=(const general_span_iterator& rhs) const noexcept
{ {
return !(rhs < *this); return !(rhs < *this);
} }
bool operator>(const general_array_view_iterator& rhs) const noexcept bool operator>(const general_span_iterator& rhs) const noexcept
{ {
return rhs < *this; return rhs < *this;
} }
bool operator>=(const general_array_view_iterator& rhs) const noexcept bool operator>=(const general_span_iterator& rhs) const noexcept
{ {
return !(rhs > *this); return !(rhs > *this);
} }
void swap(general_array_view_iterator& rhs) noexcept void swap(general_span_iterator& rhs) noexcept
{ {
std::swap(m_itr, rhs.m_itr); std::swap(m_itr, rhs.m_itr);
std::swap(m_container, rhs.m_container); std::swap(m_container, rhs.m_container);
@ -1953,7 +1953,7 @@ public:
}; };
template <typename ArrayView> template <typename ArrayView>
general_array_view_iterator<ArrayView> operator+(typename general_array_view_iterator<ArrayView>::difference_type n, const general_array_view_iterator<ArrayView>& rhs) noexcept general_span_iterator<ArrayView> operator+(typename general_span_iterator<ArrayView>::difference_type n, const general_span_iterator<ArrayView>& rhs) noexcept
{ {
return rhs + n; return rhs + n;
} }
@ -1985,4 +1985,4 @@ general_array_view_iterator<ArrayView> operator+(typename general_array_view_ite
#endif // GSL_THROWS_FOR_TESTING #endif // GSL_THROWS_FOR_TESTING
#endif // GSL_ARRAY_VIEW_H #endif // GSL_SPAN_H

59
include/string_view.h → include/string_span.h
View File

@ -16,10 +16,10 @@
#pragma once #pragma once
#ifndef GSL_STRING_VIEW_H #ifndef GSL_STRING_SPAN_H
#define GSL_STRING_VIEW_H #define GSL_STRING_SPAN_H
#include "array_view.h" #include "span.h"
#include <cstring> #include <cstring>
namespace gsl namespace gsl
@ -47,39 +47,36 @@ template<std::ptrdiff_t Max = dynamic_range>
using wzstring = wchar_t*; using wzstring = wchar_t*;
// //
// string_view and relatives // string_span and relatives
// //
// Note that Extent is always single-dimension only // Note that Extent is always single-dimension only
// Note that SizeType is defaulted to be smaller than size_t which is the array_view default
//
// TODO (neilmac) once array_view regains configurable size_type, update these typedef's
// //
template <class CharT, std::ptrdiff_t Extent = dynamic_range> template <class CharT, std::ptrdiff_t Extent = dynamic_range>
using basic_string_view = array_view<CharT, Extent>; using basic_string_span = span<CharT, Extent>;
template<std::ptrdiff_t Extent = dynamic_range> template<std::ptrdiff_t Extent = dynamic_range>
using string_view = basic_string_view<char, Extent>; using string_span = basic_string_span<char, Extent>;
template<std::ptrdiff_t Extent = dynamic_range> template<std::ptrdiff_t Extent = dynamic_range>
using cstring_view = basic_string_view<const char, Extent>; using cstring_span = basic_string_span<const char, Extent>;
template<std::ptrdiff_t Extent = dynamic_range> template<std::ptrdiff_t Extent = dynamic_range>
using wstring_view = basic_string_view<wchar_t, Extent>; using wstring_span = basic_string_span<wchar_t, Extent>;
template<std::ptrdiff_t Extent = dynamic_range> template<std::ptrdiff_t Extent = dynamic_range>
using cwstring_view = basic_string_view<const wchar_t, Extent>; using cwstring_span = basic_string_span<const wchar_t, Extent>;
// //
// ensure_sentinel() // ensure_sentinel()
// //
// Provides a way to obtain an array_view from a contiguous sequence // Provides a way to obtain an span from a contiguous sequence
// that ends with a (non-inclusive) sentinel value. // that ends with a (non-inclusive) sentinel value.
// //
// Will fail-fast if sentinel cannot be found before max elements are examined. // Will fail-fast if sentinel cannot be found before max elements are examined.
// //
template<class T, const T Sentinel> template<class T, const T Sentinel>
array_view<T, dynamic_range> ensure_sentinel(const T* seq, std::ptrdiff_t max = PTRDIFF_MAX) span<T, dynamic_range> ensure_sentinel(const T* seq, std::ptrdiff_t max = PTRDIFF_MAX)
{ {
auto cur = seq; auto cur = seq;
while ((cur - seq) < max && *cur != Sentinel) ++cur; while ((cur - seq) < max && *cur != Sentinel) ++cur;
@ -89,56 +86,56 @@ array_view<T, dynamic_range> ensure_sentinel(const T* seq, std::ptrdiff_t max =
// //
// ensure_z - creates a string_view for a czstring or cwzstring. // ensure_z - creates a string_span for a czstring or cwzstring.
// Will fail fast if a null-terminator cannot be found before // Will fail fast if a null-terminator cannot be found before
// the limit of size_type. // the limit of size_type.
// //
template<class T> template<class T>
inline basic_string_view<T, dynamic_range> ensure_z(T* const & sz, std::ptrdiff_t max = PTRDIFF_MAX) inline basic_string_span<T, dynamic_range> ensure_z(T* const & sz, std::ptrdiff_t max = PTRDIFF_MAX)
{ {
return ensure_sentinel<T, 0>(sz, max); return ensure_sentinel<T, 0>(sz, max);
} }
// TODO (neilmac) there is probably a better template-magic way to get the const and non-const overloads to share an implementation // TODO (neilmac) there is probably a better template-magic way to get the const and non-const overloads to share an implementation
inline basic_string_view<char, dynamic_range> ensure_z(char* const& sz, std::ptrdiff_t max) inline basic_string_span<char, dynamic_range> ensure_z(char* const& sz, std::ptrdiff_t max)
{ {
auto len = strnlen(sz, max); auto len = strnlen(sz, max);
fail_fast_assert(sz[len] == 0); fail_fast_assert(sz[len] == 0);
return{ sz, static_cast<std::ptrdiff_t>(len) }; return{ sz, static_cast<std::ptrdiff_t>(len) };
} }
inline basic_string_view<const char, dynamic_range> ensure_z(const char* const& sz, std::ptrdiff_t max) inline basic_string_span<const char, dynamic_range> ensure_z(const char* const& sz, std::ptrdiff_t max)
{ {
auto len = strnlen(sz, max); auto len = strnlen(sz, max);
fail_fast_assert(sz[len] == 0); return{ sz, static_cast<std::ptrdiff_t>(len) }; fail_fast_assert(sz[len] == 0); return{ sz, static_cast<std::ptrdiff_t>(len) };
} }
inline basic_string_view<wchar_t, dynamic_range> ensure_z(wchar_t* const& sz, std::ptrdiff_t max) inline basic_string_span<wchar_t, dynamic_range> ensure_z(wchar_t* const& sz, std::ptrdiff_t max)
{ {
auto len = wcsnlen(sz, max); auto len = wcsnlen(sz, max);
fail_fast_assert(sz[len] == 0); return{ sz, static_cast<std::ptrdiff_t>(len) }; fail_fast_assert(sz[len] == 0); return{ sz, static_cast<std::ptrdiff_t>(len) };
} }
inline basic_string_view<const wchar_t, dynamic_range> ensure_z(const wchar_t* const& sz, std::ptrdiff_t max) inline basic_string_span<const wchar_t, dynamic_range> ensure_z(const wchar_t* const& sz, std::ptrdiff_t max)
{ {
auto len = wcsnlen(sz, max); auto len = wcsnlen(sz, max);
fail_fast_assert(sz[len] == 0); return{ sz, static_cast<std::ptrdiff_t>(len) }; fail_fast_assert(sz[len] == 0); return{ sz, static_cast<std::ptrdiff_t>(len) };
} }
template<class T, size_t N> template<class T, size_t N>
basic_string_view<T, dynamic_range> ensure_z(T(&sz)[N]) { return ensure_z(&sz[0], static_cast<std::ptrdiff_t>(N)); } basic_string_span<T, dynamic_range> ensure_z(T(&sz)[N]) { return ensure_z(&sz[0], static_cast<std::ptrdiff_t>(N)); }
template<class Cont> template<class Cont>
basic_string_view<typename std::remove_pointer<typename Cont::pointer>::type, dynamic_range> ensure_z(Cont& cont) basic_string_span<typename std::remove_pointer<typename Cont::pointer>::type, dynamic_range> ensure_z(Cont& cont)
{ {
return ensure_z(cont.data(), cont.length()); return ensure_z(cont.data(), cont.length());
} }
// //
// to_string() allow (explicit) conversions from string_view to string // to_string() allow (explicit) conversions from string_span to string
// //
template<class CharT, size_t Extent> template<class CharT, size_t Extent>
std::basic_string<typename std::remove_const<CharT>::type> to_string(basic_string_view<CharT, Extent> view) std::basic_string<typename std::remove_const<CharT>::type> to_string(basic_string_span<CharT, Extent> view)
{ {
return{ view.data(), view.length() }; return{ view.data(), view.length() };
} }
@ -148,11 +145,11 @@ template<class CharT, size_t Extent = dynamic_range>
class basic_zstring_builder class basic_zstring_builder
{ {
public: public:
using string_view_type = basic_string_view<CharT, Extent>; using string_span_type = basic_string_span<CharT, Extent>;
using value_type = CharT; using value_type = CharT;
using pointer = CharT*; using pointer = CharT*;
using size_type = typename string_view_type::size_type; using size_type = typename string_span_type::size_type;
using iterator = typename string_view_type::iterator; using iterator = typename string_span_type::iterator;
basic_zstring_builder(CharT* data, size_type length) : sv_(data, length) {} basic_zstring_builder(CharT* data, size_type length) : sv_(data, length) {}
@ -160,18 +157,18 @@ public:
basic_zstring_builder(CharT(&arr)[Size]) : sv_(arr) {} basic_zstring_builder(CharT(&arr)[Size]) : sv_(arr) {}
pointer data() const { return sv_.data(); } pointer data() const { return sv_.data(); }
string_view_type view() const { return sv_; } string_span_type view() const { return sv_; }
size_type length() const { return sv_.length(); } size_type length() const { return sv_.length(); }
pointer assume0() const { return data(); } pointer assume0() const { return data(); }
string_view_type ensure_z() const { return gsl::ensure_z(sv_); } string_span_type ensure_z() const { return gsl::ensure_z(sv_); }
iterator begin() const { return sv_.begin(); } iterator begin() const { return sv_.begin(); }
iterator end() const { return sv_.end(); } iterator end() const { return sv_.end(); }
private: private:
string_view_type sv_; string_span_type sv_;
}; };
template <size_t Max = dynamic_range> template <size_t Max = dynamic_range>
@ -181,4 +178,4 @@ template <size_t Max = dynamic_range>
using wzstring_builder = basic_zstring_builder<wchar_t, Max>; using wzstring_builder = basic_zstring_builder<wchar_t, Max>;
} }
#endif // GSL_STRING_VIEW_H #endif // GSL_STRING_SPAN_H

4
tests/CMakeLists.txt
View File

@ -43,8 +43,8 @@ function(add_gsl_test name)
) )
endfunction() endfunction()
add_gsl_test(array_view_tests) add_gsl_test(span_tests)
add_gsl_test(string_view_tests) add_gsl_test(string_span_tests)
add_gsl_test(at_tests) add_gsl_test(at_tests)
add_gsl_test(bounds_tests) add_gsl_test(bounds_tests)
add_gsl_test(notnull_tests) add_gsl_test(notnull_tests)

4
tests/bounds_tests.cpp
View File

@ -15,7 +15,7 @@
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#include <UnitTest++/UnitTest++.h> #include <UnitTest++/UnitTest++.h>
#include <array_view.h> #include <span.h>
#include <vector> #include <vector>
using namespace std; using namespace std;
@ -55,7 +55,7 @@ SUITE(bounds_test)
auto itr = bounds.begin(); auto itr = bounds.begin();
#ifdef CONFIRM_COMPILATION_ERRORS #ifdef CONFIRM_COMPILATION_ERRORS
array_view<int, 4, dynamic_range, 2> av(nullptr, bounds); span<int, 4, dynamic_range, 2> av(nullptr, bounds);
auto itr2 = av.cbegin(); auto itr2 = av.cbegin();

600
tests/array_view_tests.cpp → tests/span_tests.cpp
View File

File diff suppressed because it is too large Load Diff

32
tests/string_view_tests.cpp → tests/string_span_tests.cpp
View File

@ -15,38 +15,38 @@
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#include <UnitTest++/UnitTest++.h> #include <UnitTest++/UnitTest++.h>
#include <string_view.h> #include <string_span.h>
#include <vector> #include <vector>
#include <cstdlib> #include <cstdlib>
using namespace std; using namespace std;
using namespace gsl; using namespace gsl;
SUITE(string_view_tests) SUITE(string_span_tests)
{ {
TEST(TestLiteralConstruction) TEST(TestLiteralConstruction)
{ {
cwstring_view<> v = ensure_z(L"Hello"); cwstring_span<> v = ensure_z(L"Hello");
CHECK(5 == v.length()); CHECK(5 == v.length());
#ifdef CONFIRM_COMPILATION_ERRORS #ifdef CONFIRM_COMPILATION_ERRORS
wstring_view<> v2 = ensure0(L"Hello"); wstring_span<> v2 = ensure0(L"Hello");
#endif #endif
} }
TEST(TestConstructFromStdString) TEST(TestConstructFromStdString)
{ {
std::string s = "Hello there world"; std::string s = "Hello there world";
cstring_view<> v = s; cstring_span<> v = s;
CHECK(v.length() == s.length()); CHECK(v.length() == s.length());
} }
TEST(TestConstructFromStdVector) TEST(TestConstructFromStdVector)
{ {
std::vector<char> vec(5, 'h'); std::vector<char> vec(5, 'h');
string_view<> v = vec; string_span<> v = vec;
CHECK(v.length() == vec.size()); CHECK(v.length() == vec.size());
} }
@ -55,25 +55,25 @@ SUITE(string_view_tests)
wchar_t stack_string[] = L"Hello"; wchar_t stack_string[] = L"Hello";
{ {
cwstring_view<> v = ensure_z(stack_string); cwstring_span<> v = ensure_z(stack_string);
CHECK(v.length() == 5); CHECK(v.length() == 5);
CHECK(v.used_length() == v.length()); CHECK(v.used_length() == v.length());
} }
{ {
cwstring_view<> v = stack_string; cwstring_span<> v = stack_string;
CHECK(v.length() == 6); CHECK(v.length() == 6);
CHECK(v.used_length() == v.length()); CHECK(v.used_length() == v.length());
} }
{ {
wstring_view<> v = ensure_z(stack_string); wstring_span<> v = ensure_z(stack_string);
CHECK(v.length() == 5); CHECK(v.length() == 5);
CHECK(v.used_length() == v.length()); CHECK(v.used_length() == v.length());
} }
{ {
wstring_view<> v = stack_string; wstring_span<> v = stack_string;
CHECK(v.length() == 6); CHECK(v.length() == 6);
CHECK(v.used_length() == v.length()); CHECK(v.used_length() == v.length());
} }
@ -82,7 +82,7 @@ SUITE(string_view_tests)
TEST(TestConstructFromConstCharPointer) TEST(TestConstructFromConstCharPointer)
{ {
const char* s = "Hello"; const char* s = "Hello";
cstring_view<> v = ensure_z(s); cstring_span<> v = ensure_z(s);
CHECK(v.length() == 5); CHECK(v.length() == 5);
CHECK(v.used_length() == v.length()); CHECK(v.used_length() == v.length());
} }
@ -90,18 +90,18 @@ SUITE(string_view_tests)
TEST(TestConversionToConst) TEST(TestConversionToConst)
{ {
char stack_string[] = "Hello"; char stack_string[] = "Hello";
string_view<> v = ensure_z(stack_string); string_span<> v = ensure_z(stack_string);
cstring_view<> v2 = v; cstring_span<> v2 = v;
CHECK(v.length() == v2.length()); CHECK(v.length() == v2.length());
} }
TEST(TestConversionFromConst) TEST(TestConversionFromConst)
{ {
char stack_string[] = "Hello"; char stack_string[] = "Hello";
cstring_view<> v = ensure_z(stack_string); cstring_span<> v = ensure_z(stack_string);
#ifdef CONFIRM_COMPILATION_ERRORS #ifdef CONFIRM_COMPILATION_ERRORS
string_view<> v2 = v; string_span<> v2 = v;
string_view<> v3 = "Hello"; string_span<> v3 = "Hello";
#endif #endif
} }
} }