#include "cetl/pf20/span.hpp"

Public Types
using	element_type = T

using	value_type = typename std::remove_cv<T>::type

using	pointer = T*

using	const_pointer = const T*

using	reference = T&

using	const_reference = const T&

using	size_type = std::size_t

using	difference_type = std::ptrdiff_t

using	iterator = pointer

using	reverse_iterator = std::reverse_iterator<iterator>

Public Member Functions
Constructors
template<std::size_t DeducedExtent = Extent, typename std::enable_if<(DeducedExtent==0), bool >::type = true>
constexpr	span () noexcept

constexpr	span (iterator first, size_type count)

template<typename EndType, typename std::enable_if<!std::is_convertible< EndType, std::size_t >::value, bool >::type = true>
constexpr	span (pointer first, EndType end)

template<std::size_t DeducedExtent = Extent, typename std::enable_if<(DeducedExtent !=0), bool >::type = true>
constexpr	span (element_type(&arr)[DeducedExtent]) noexcept

template<typename ArrayElementType, typename std::enable_if< std::is_convertible< ArrayElementType()[], T()[]>::value, bool >::type = true>
constexpr	span (std::array< ArrayElementType, Extent > &arr) noexcept

template<typename ArrayElementType, typename std::enable_if< std::is_convertible< const ArrayElementType()[], T()[]>::value, bool >::type = true>
constexpr	span (const std::array< ArrayElementType, Extent > &arr) noexcept

template<typename DeducedElementType, typename std::enable_if< std::is_convertible< DeducedElementType()[], element_type()[]>::value, bool >::type = true>
constexpr	span (const span< DeducedElementType, dynamic_extent > &source) noexcept

template<typename DeducedElementType, typename std::enable_if< std::is_convertible< DeducedElementType()[], element_type()[]>::value, bool >::type = true>
constexpr	span (const span< DeducedElementType, Extent > &source) noexcept

constexpr	span (const span &) noexcept=default

Operators
constexpr span &	operator= (const span &rhs) noexcept=default

constexpr reference	operator[] (size_type idx) const

Iterators
constexpr iterator	begin () const noexcept

constexpr iterator	end () const noexcept

constexpr reverse_iterator	rbegin () const noexcept

constexpr reverse_iterator	rend () const noexcept

Element Access
constexpr reference	front () const

constexpr reference	back () const

constexpr pointer	data () const noexcept

Observers
constexpr bool	empty () const noexcept

constexpr size_type	size () const noexcept

constexpr size_type	size_bytes () const noexcept

sub-views
template<size_type Count>
constexpr span< element_type, Count >	first () const

constexpr span< element_type, dynamic_extent >	first (size_type count) const

template<size_type Count>
constexpr span< element_type, Count >	last () const

constexpr span< element_type, dynamic_extent >	last (size_type count) const

template<size_type Offset, size_type Count = dynamic_extent>
constexpr span< element_type,(Count !=dynamic_extent) ? Count :Extent - Offset >	subspan () const

constexpr span< element_type, dynamic_extent >	subspan (size_type Offset, size_type Count=dynamic_extent) const

Static Public Attributes
static constexpr std::size_t	extent = Extent

Detailed Description

template<typename T, std::size_t Extent>
class cetl::pf20::span< T, Extent >

A borrowed view into a contiguous set of objects.

This version is for spans where the extent is static (see span< T, dynamic_extent > for the dynamic extent specialization)

Spans can either be static, where the set of objects is fixed and known, or dynamic where the number of objects in the contiguous set may change. This template is compatible with class: std::span available in C++20.

Example: Creating a stream operator for cetl::span...
template<typename T, std::size_t Extent>

std::ostream& operator<<(std::ostream& os, const cetl::pf20::span<T, Extent>& sp)

{

std::for_each(sp.begin(), sp.end(), [&os](const char c) { os << c; });

return os;

}

...enables trivial printing of substrings without allocation of a new buffer.
constexpr const char* greeting = "Hello Static World";

std::cout << cetl::pf20::span<const char, 12>{greeting, 12} << std::endl;

(See full example here...)

Template Parameters

T	The element type.
Extent	The extent type of this span; either dynamic or static.

Member Typedef Documentation

◆ const_pointer

template<typename T, std::size_t Extent>

using cetl::pf20::span< T, Extent >::const_pointer = const T*

A constant pointer to the element type.

◆ const_reference

template<typename T, std::size_t Extent>

using cetl::pf20::span< T, Extent >::const_reference = const T&

A constant reference type to the element.

◆ difference_type

template<typename T, std::size_t Extent>

using cetl::pf20::span< T, Extent >::difference_type = std::ptrdiff_t

Type used to compare two locations in the span.

◆ element_type

template<typename T, std::size_t Extent>

using cetl::pf20::span< T, Extent >::element_type = T

The element type over which the span operates.

◆ iterator

template<typename T, std::size_t Extent>

using cetl::pf20::span< T, Extent >::iterator = pointer

Type for iterating through the span.

◆ pointer

template<typename T, std::size_t Extent>

using cetl::pf20::span< T, Extent >::pointer = T*

The element pointer type.

◆ reference

template<typename T, std::size_t Extent>

using cetl::pf20::span< T, Extent >::reference = T&

A reference type to the element.

◆ reverse_iterator

template<typename T, std::size_t Extent>

using cetl::pf20::span< T, Extent >::reverse_iterator = std::reverse_iterator<iterator>

Reverse iterator type.

◆ size_type

template<typename T, std::size_t Extent>

using cetl::pf20::span< T, Extent >::size_type = std::size_t

Used to track the size in bytes.

◆ value_type

template<typename T, std::size_t Extent>

using cetl::pf20::span< T, Extent >::value_type = typename std::remove_cv<T>::type

The non-cv type of elements.

Constructor & Destructor Documentation

◆ span() [1/9]

template<typename T, std::size_t Extent>

template<std::size_t DeducedExtent = Extent, typename std::enable_if<(DeducedExtent==0), bool >::type = true>

cetl::pf20::span< T, Extent >::span ( )

inlineconstexprnoexcept

Default constructor.

Template Parameters

DeducedExtent	The Extent deduced by the compiler.
type	SFINAE enablement of this constructor only where the extent > 0.

See also: std::span::span()

Referenced by first(), first(), last(), last(), operator=(), span(), span(), span(), subspan(), and subspan().

Here is the caller graph for this function:

◆ span() [2/9]

template<typename T, std::size_t Extent>

cetl::pf20::span< T, Extent >::span	(	iterator	first,
		size_type	count )

inlineexplicitconstexpr

Creates a span starting at an element for a given length.

The span's view into the data starts at the element pointed to by the first pointer. The size of the span is provided by the count where it is undefined behavior to provide a count value that is not the same as span::extent.

Parameters

first	The first element in the span.
count	The number of elements in the span.

See also: std::span::span()

References CETL_DEBUG_ASSERT, extent, and first().

◆ span() [3/9]

template<typename T, std::size_t Extent>

template<typename EndType, typename std::enable_if<!std::is_convertible< EndType, std::size_t >::value, bool >::type = true>

cetl::pf20::span< T, Extent >::span	(	pointer	first,
		EndType	end )

inlineexplicitconstexpr

Creates a span starting at an element to the element before the given end.

That is, span == [first, end). It is undefined to provide iterators where end - first != Extent

Template Parameters

EndType	End iterator type is deduced to support SFINAE pattern.
type	Participates in overload resolution only if the EndType cannot be converted to size_type.

Parameters

first	The first element in the span.
end	The element after the last element in the span.

See also: std::span::span()

References CETL_DEBUG_ASSERT, std::distance(), end(), and first().

◆ span() [4/9]

template<typename T, std::size_t Extent>

template<std::size_t DeducedExtent = Extent, typename std::enable_if<(DeducedExtent !=0), bool >::type = true>

cetl::pf20::span< T, Extent >::span ( element_type(&) arr[DeducedExtent] )

inlineconstexprnoexcept

Creates a span starting at the first element of a c-style array through to the end of that array.

Parameters

arr	Reference to a C-style array.

See also: std::span::span()

◆ span() [5/9]

template<typename T, std::size_t Extent>

template<typename ArrayElementType, typename std::enable_if< std::is_convertible< ArrayElementType(*)[], T(*)[]>::value, bool >::type = true>

cetl::pf20::span< T, Extent >::span ( std::array< ArrayElementType, Extent > & arr )

inlineconstexprnoexcept

Creates a span over an entire std::array starting at the array's first element.

Template Parameters

ArrayElementType	Deduced array element type to support SFINAE enablement.
type	Enables this override only if the array's element type is the same as the span's or if the conversion is a simple qualification conversion.

Parameters

arr	The array to create the view into.

See also: std::span::span()

◆ span() [6/9]

template<typename T, std::size_t Extent>

template<typename ArrayElementType, typename std::enable_if< std::is_convertible< const ArrayElementType(*)[], T(*)[]>::value, bool >::type = true>

cetl::pf20::span< T, Extent >::span ( const std::array< ArrayElementType, Extent > & arr )

inlineconstexprnoexcept

Creates a span over an entire const std::array starting at the array's first element.

Template Parameters

ArrayElementType	Deduced array element type to support SFINAE enablement.
type	Enables this override only if the array's element type is the same as the span's or if the conversion is a simple qualification conversion.

Parameters

arr	The array to create the view into.

See also: std::span::span()

◆ span() [7/9]

template<typename T, std::size_t Extent>

template<typename DeducedElementType, typename std::enable_if< std::is_convertible< DeducedElementType(*)[], element_type(*)[]>::value, bool >::type = true>

cetl::pf20::span< T, Extent >::span ( const span< DeducedElementType, dynamic_extent > & source )

inlineexplicitconstexprnoexcept

Copy constructor to create a span from another span.

This overload allows conversion of a dynamic span of size() N to a static span with an extent of N. It is undefined to provide a source span with a size() != this span's size.

Template Parameters

DeducedElementType	The element type of the source span.
type	Enables this override only if the element conversion is a simple qualification conversion.

Parameters

source The span to copy from. The resulting span has size() == source.size() and data() == / source.data()

See also: std::span(std::span&)

References CETL_DEBUG_ASSERT, extent, and span().

◆ span() [8/9]

template<typename T, std::size_t Extent>

template<typename DeducedElementType, typename std::enable_if< std::is_convertible< DeducedElementType(*)[], element_type(*)[]>::value, bool >::type = true>

cetl::pf20::span< T, Extent >::span ( const span< DeducedElementType, Extent > & source )

inlineconstexprnoexcept

Copy constructor to create a span from another span.

Template Parameters

DeducedElementType	The element type of the source span.
type	Enables this override only if the element conversion is a simple qualification conversion.

Parameters

source The span to copy from. The resulting span has size() == source.size() and data() == source.data(). For this overload extent == source::extent is also true and extent != dynamic_extent.

See also: std::span()

References span().

◆ span() [9/9]

template<typename T, std::size_t Extent>

cetl::pf20::span< T, Extent >::span ( const span< T, Extent > & )

constexprdefaultnoexcept

Default copy constructor.

See also: std::span::span()

References span().

Member Function Documentation

◆ back()

template<typename T, std::size_t Extent>

reference cetl::pf20::span< T, Extent >::back ( ) const

inlineconstexpr

Returns a reference to the last element.

Calling this method on an empty span is undefined.

Returns: Reference to the last element. This is the same as *(obj.end() - 1).

See also: std::span::back

References CETL_DEBUG_ASSERT.

◆ begin()

template<typename T, std::size_t Extent>

iterator cetl::pf20::span< T, Extent >::begin ( ) const

inlineconstexprnoexcept

Iterator to the first element in the span.

This is the same as span::end() if the size of the span is 0.

Returns: normal iterator.

See also: std::span::begin

Referenced by front(), and rend().

Here is the caller graph for this function:

◆ data()

template<typename T, std::size_t Extent>

pointer cetl::pf20::span< T, Extent >::data ( ) const

inlineconstexprnoexcept

Provides access to the internal data the span is a view into.

Returns: A pointer to the beginning of the span sequence.

See also: std::span::data

◆ empty()

template<typename T, std::size_t Extent>

bool cetl::pf20::span< T, Extent >::empty ( ) const

inlineconstexprnoexcept

If the span has a zero size or not.

Returns: true if the span size is 0 where "size" is the same as span::extent for this specialization.

◆ end()

template<typename T, std::size_t Extent>

iterator cetl::pf20::span< T, Extent >::end ( ) const

inlineconstexprnoexcept

Iterator to the address after the last element in the span.

             end
              v
+-----------------------+
|0| 1 | 2 | 3 | x | x |
+-----------------------+

Returns: normal iterator.

See also: std::span::end

Referenced by rbegin(), and span().

Here is the caller graph for this function:

◆ first() [1/2]

template<typename T, std::size_t Extent>

template<size_type Count>

span< element_type, Count > cetl::pf20::span< T, Extent >::first ( ) const

inlineconstexpr

Create a new span from the start of the current span for Count elements.

Template Parameters

Count Number of elements for the sub-span.

Returns: A new span with the static extent Count.

See also: std::span::first

References span().

Referenced by span(), and span().

Here is the caller graph for this function:

◆ first() [2/2]

template<typename T, std::size_t Extent>

span< element_type, dynamic_extent > cetl::pf20::span< T, Extent >::first ( size_type count ) const

inlineconstexpr

Create a new span from the start of the current span for count elements.

Parameters

count The number of elements for the sub-span. Where count is greater than the current span's size the behavior is undefined.

Returns: A new span with a dynamic extent extent and a size of count.

See also: std::span::first

References CETL_DEBUG_ASSERT, and span().

◆ front()

template<typename T, std::size_t Extent>

reference cetl::pf20::span< T, Extent >::front ( ) const

inlineconstexpr

Returns a reference to the first element.

Calling this method on an empty span is undefined.

Returns: Reference to the first element. This is the same as *obj.begin().

See also: std::span::front

References begin(), and CETL_DEBUG_ASSERT.

◆ last() [1/2]

template<typename T, std::size_t Extent>

template<size_type Count>

span< element_type, Count > cetl::pf20::span< T, Extent >::last ( ) const

inlineconstexpr

Create a new span Count elements from the last item of the current span to its end.

Template Parameters

Count Number of elements for the sub-span.

Returns: A new span with the static extent Count.

See also: std::span::last

References extent, and span().

◆ last() [2/2]

template<typename T, std::size_t Extent>

span< element_type, dynamic_extent > cetl::pf20::span< T, Extent >::last ( size_type count ) const

inlineconstexpr

Create a new span count elements from the last item of the current span to its end.

Parameters

count Number of elements for the sub-span. The behavior of this method is undefined where count is greater than the current span's size.

Returns: A new span with a size of count and a dynamic extent.

See also: std::span::last

References CETL_DEBUG_ASSERT, extent, and span().

◆ operator=()

template<typename T, std::size_t Extent>

span & cetl::pf20::span< T, Extent >::operator= ( const span< T, Extent > & rhs )

constexprdefaultnoexcept

Default assignment operator.

Parameters

rhs	Right-hand-side of the assignment expression.

Returns: reference to *this

See also: std::span::operator=()

References span().

◆ operator[]()

template<typename T, std::size_t Extent>

reference cetl::pf20::span< T, Extent >::operator[] ( size_type idx ) const

inlineconstexpr

Reference to an element in the span.

Parameters

idx	The 0-based index in the span. The behavior of this method is undefined if idx is >= to size.

Returns: A reference to an element.

See also: std::span::operator[]()

References CETL_DEBUG_ASSERT.

◆ rbegin()

template<typename T, std::size_t Extent>

reverse_iterator cetl::pf20::span< T, Extent >::rbegin ( ) const

inlineconstexprnoexcept

Reverse iterator to the last element in the span.

This is the same as span::rend if the span size is 0.

Returns: reverse iterator after the end of the span.

See also: std::span::rbegin

References end().

◆ rend()

template<typename T, std::size_t Extent>

reverse_iterator cetl::pf20::span< T, Extent >::rend ( ) const

inlineconstexprnoexcept

Reverse iterator to the address before the first element in the span.

rend
v
+-----------------------+
| 0 | 1 | 2 | 3 | x | x |
+-----------------------+

Returns: reverse iterator from the beginning of the span.

See also: std::span::rend

References begin().

◆ size()

template<typename T, std::size_t Extent>

size_type cetl::pf20::span< T, Extent >::size ( ) const

inlineconstexprnoexcept

The size of the span.

Returns: The number of elements in the span which is equal to span::extent.

See also: std::span::size

Referenced by subspan(), and subspan().

Here is the caller graph for this function:

◆ size_bytes()

template<typename T, std::size_t Extent>

size_type cetl::pf20::span< T, Extent >::size_bytes ( ) const

inlineconstexprnoexcept

The size of the span in bytes.

Returns: sizeof(element_type) * size_.

See also: std::span::size_bytes

◆ subspan() [1/2]

template<typename T, std::size_t Extent>

template<size_type Offset, size_type Count = dynamic_extent>

span< element_type,(Count !=dynamic_extent) ? Count :Extent - Offset > cetl::pf20::span< T, Extent >::subspan ( ) const

inlineconstexpr

Create a new span Offset elements from the start of the current span and for Count elements.

Template Parameters

Offset	Number of elements from the start of the current span for the subspan.
Count	The number of elements from the Offset to include in the subspan. If this value is `dynamic_extent` then the Count is `size() - Offset`.

Returns: A new span where the Extent is Count if this was not dynamic_extent otherwise the new span's Extent is this span's Extent minus Offset.

See also: std::span::subspan()

References cetl::pf20::dynamic_extent, extent, size(), span(), and subspan().

Referenced by subspan(), and subspan().

Here is the caller graph for this function:

◆ subspan() [2/2]

template<typename T, std::size_t Extent>

span< element_type, dynamic_extent > cetl::pf20::span< T, Extent >::subspan	(	size_type	Offset,
		size_type	Count = dynamic_extent ) const

inlineconstexpr

Create a new span Offset elements from the start of the current span and for either Count elements or, if Count is dynamic_extent, for the remaining size of the span (i.e.

size() - Offset). The behavior of this method is undefined where Count is greater-than the size of this span or if Count is not dynamic_extent but Count is greater-than size() - Offset.

Parameters

Offset	Number of elements from the start of the current span for the subspan.
Count	The number of elements from the Offset to include in the subspan. If this value is `dynamic_extent` then the Count is `size() - Offset`.

Returns: A new span with a dynamic extent.

See also: std::span::subspan()

References CETL_DEBUG_ASSERT, cetl::pf20::dynamic_extent, size(), span(), and subspan().

Member Data Documentation

◆ extent

template<typename T, std::size_t Extent>

std::size_t cetl::pf20::span< T, Extent >::extent = Extent

staticconstexpr

The value of Extent for this template instantiation.

Referenced by last(), last(), span(), span(), and subspan().

The documentation for this class was generated from the following file:

/__w/CETL/CETL/include/cetl/pf20/span.hpp

	CETL 0.0.0

Public Types

Public Member Functions

Static Public Attributes

Detailed Description

Member Typedef Documentation

◆ const_pointer

◆ const_reference

◆ difference_type

◆ element_type

◆ iterator

◆ pointer

◆ reference

◆ reverse_iterator

◆ size_type

◆ value_type

Constructor & Destructor Documentation

◆ span() [1/9]

◆ span() [2/9]

◆ span() [3/9]

◆ span() [4/9]

◆ span() [5/9]

◆ span() [6/9]

◆ span() [7/9]

◆ span() [8/9]

◆ span() [9/9]

Member Function Documentation

◆ back()

◆ begin()

◆ data()

◆ empty()

◆ end()

◆ first() [1/2]

◆ first() [2/2]

◆ front()

◆ last() [1/2]

◆ last() [2/2]

◆ operator=()

◆ operator[]()

◆ rbegin()

◆ rend()

◆ size()

◆ size_bytes()

◆ subspan() [1/2]

◆ subspan() [2/2]

Member Data Documentation

◆ extent