cetl::pf20::span< T, dynamic_extent > Class Template Reference

#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>
using	element_type
using	value_type
using	pointer
using	const_pointer
using	reference
using	const_reference
using	size_type
using	difference_type
using	iterator
using	reverse_iterator

Public Member Functions
Constructors
constexpr	span () noexcept
constexpr	span (iterator first, size_type count)
template<typename EndType, typename std::enable_if<!std::is_convertible< EndType, size_type >::value, bool >::type = true>
constexpr	span (pointer first, EndType end)
template<std::size_t ArrayLen>
constexpr	span (element_type(&arr)[ArrayLen]) noexcept
template<typename ArrayElementType, std::size_t ArrayLen, typename std::enable_if< std::is_convertible< ArrayElementType(*)[], T(*)[]>::value, bool >::type = true>
constexpr	span (std::array< ArrayElementType, ArrayLen > &arr) noexcept
template<typename ArrayElementType, std::size_t ArrayLen, typename std::enable_if< std::is_convertible< const ArrayElementType(*)[], T(*)[]>::value, bool >::type = true>
constexpr	span (const std::array< ArrayElementType, ArrayLen > &arr) noexcept
template<class DeducedElementType, size_type DeducedExtent, typename std::enable_if< std::is_convertible< DeducedElementType(*)[], element_type(*)[]>::value, bool >::type = true>
constexpr	span (const span< DeducedElementType, DeducedExtent > &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 >	subspan () const
constexpr span< element_type, dynamic_extent >	subspan (size_type Offset, size_type Count=dynamic_extent) const
Constructors
constexpr	span () noexcept
constexpr	span (iterator first, size_type count)
constexpr	span (pointer first, EndType end)
constexpr	span (element_type(&arr)[DeducedExtent]) noexcept
constexpr	span (std::array< ArrayElementType, Extent > &arr) noexcept
constexpr	span (const std::array< ArrayElementType, Extent > &arr) noexcept
constexpr	span (const span< DeducedElementType, dynamic_extent > &source) noexcept
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
constexpr span< element_type, Count >	first () const
constexpr span< element_type, dynamic_extent >	first (size_type count) const
constexpr span< element_type, Count >	last () const
constexpr span< element_type, dynamic_extent >	last (size_type count) const
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 = dynamic_extent
static constexpr std::size_t	extent

Detailed Description

template<typename T>
class cetl::pf20::span< T, dynamic_extent >

Specialization of span where the extent is dynamic.

std::string greeting{"Hello Dynamic World."};
// Works just like a std::span...
cetl::pf20::span<const char> dynamic{greeting.c_str(), 13};
auto print = [](const char c) { std::cout << c; };
 
// Print just the characters in the span...
std::for_each(dynamic.begin(), dynamic.end(), print);
std::cout << std::endl;
 
// or...
std::string substring{dynamic.begin(), dynamic.size()};
std::cout << substring << std::endl;

Member Typedef Documentation

const_pointer [1/2]

using cetl::pf20::span< T, Extent >::const_pointer

A constant pointer to the element type.

const_pointer [2/2]

template<typename T>

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

A constant pointer to the element type.

const_reference [1/2]

using cetl::pf20::span< T, Extent >::const_reference

A constant reference type to the element.

const_reference [2/2]

template<typename T>

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

A constant reference type to the element.

difference_type [1/2]

using cetl::pf20::span< T, Extent >::difference_type

Type used to compare two locations in the span.

difference_type [2/2]

template<typename T>

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

Type used to compare two locations in the span.

element_type [1/2]

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

The element type over which the span operates.

element_type [2/2]

template<typename T>

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

The element type over which the span operates.

iterator [1/2]

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

Type for iterating through the span.

iterator [2/2]

template<typename T>

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

Type for iterating through the span.

pointer [1/2]

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

The element pointer type.

pointer [2/2]

template<typename T>

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

The element pointer type.

reference [1/2]

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

A reference type to the element.

reference [2/2]

template<typename T>

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

A reference type to the element.

reverse_iterator [1/2]

using cetl::pf20::span< T, Extent >::reverse_iterator

Reverse iterator type.

reverse_iterator [2/2]

template<typename T>

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

Reverse iterator type.

size_type [1/2]

using cetl::pf20::span< T, Extent >::size_type

Used to track the size in bytes.

size_type [2/2]

template<typename T>

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

Used to track the size in bytes.

value_type [1/2]

using cetl::pf20::span< T, Extent >::value_type

The non-cv type of elements.

value_type [2/2]

template<typename T>

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

The non-cv type of elements.

Constructor & Destructor Documentation

span() [1/17]

template<typename T>

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

inlineconstexprnoexcept

Default constructor.

See also

std::span::span()

Referenced by back(), first(), front(), last(), and operator[]().

Here is the caller graph for this function:

span() [2/17]

template<typename T>

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

inlineconstexpr

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.

Parameters

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

See also

std::span::span()

span() [3/17]

template<typename T>

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

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

inlineconstexpr

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

That is, span == [first, end). The size of the span becomes end - first.

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 end(), and first().

span() [4/17]

template<typename T>

template<std::size_t ArrayLen>

cetl::pf20::span< T, dynamic_extent >::span ( element_type(&) arr[ArrayLen] )

inlineconstexprnoexcept

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

Template Parameters

ArrayLen

Deduced length of the c array to become the size of the span.

Parameters

arr	Reference to a C-style array.

See also

std::span::span()

span() [5/17]

template<typename T>

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

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

inlineconstexprnoexcept

Creates a span over an entire std::array starting at the array's first element and with a size set to ArrayLen.

Template Parameters

ArrayElementType	Deduced array element type to support SFINAE enablement.
ArrayLen	The length of the array. span::size() is set to this value.
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/17]

template<typename T>

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

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

inlineconstexprnoexcept

Creates a span over an entire const std::array starting at the array's first element and with a size set to ArrayLen.

Template Parameters

ArrayElementType	Deduced array element type to support SFINAE enablement.
ArrayLen	The length of the array. span::size() is set to this value.
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/17]

template<typename T>

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

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

inlineconstexprnoexcept

Copy constructor to create a span from another span.

This overload allows conversion of any span to a dynamic span.

Template Parameters

DeducedElementType	The element type of the source span.
DeducedExtent	The extent 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()

span() [8/17]

template<typename T>

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

constexprdefaultnoexcept

Default copy constructor.

See also

std::span::span()

span() [9/17]

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()

span() [10/17]

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()

span() [11/17]

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()

span() [12/17]

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() [13/17]

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() [14/17]

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() [15/17]

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&)

span() [16/17]

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()

span() [17/17]

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

constexprdefaultnoexcept

Default copy constructor.

See also

std::span::span()

Member Function Documentation

back() [1/2]

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

back() [2/2]

template<typename T>

reference cetl::pf20::span< T, dynamic_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 back(), empty(), and span().

Referenced by back().

Here is the caller graph for this function:

begin() [1/2]

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

begin() [2/2]

template<typename T>

iterator cetl::pf20::span< T, dynamic_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

data() [1/2]

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

data() [2/2]

template<typename T>

pointer cetl::pf20::span< T, dynamic_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

Referenced by operator[]().

Here is the caller graph for this function:

empty() [1/2]

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.

empty() [2/2]

template<typename T>

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

inlineconstexprnoexcept

Returns if the span has a zero size or not.

Returns

true if the span size is 0.

Referenced by back(), and front().

Here is the caller graph for this function:

end() [1/2]

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

end() [2/2]

template<typename T>

iterator cetl::pf20::span< T, dynamic_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 span().

Here is the caller graph for this function:

first() [1/4]

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

first() [2/4]

template<typename T>

template<size_type Count>

span< element_type, Count > cetl::pf20::span< T, dynamic_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. The behavior of this method and the returned span is undefined if Count is greater than this span's size

Returns

A new span with the static extent Count.

See also

std::span::first

References size(), and span().

Referenced by span().

Here is the caller graph for this function:

first() [3/4]

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

first() [4/4]

template<typename T>

span< element_type, dynamic_extent > cetl::pf20::span< T, dynamic_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

front() [1/2]

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

front() [2/2]

template<typename T>

reference cetl::pf20::span< T, dynamic_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 empty(), front(), and span().

Referenced by front().

Here is the caller graph for this function:

last() [1/4]

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

last() [2/4]

template<typename T>

template<size_type Count>

span< element_type, Count > cetl::pf20::span< T, dynamic_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. The behavior of this method is undefined where Count is greater than the span's current size.

Returns

A new span with the static extent Count.

See also

std::span::last

References size(), and span().

last() [3/4]

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

last() [4/4]

template<typename T>

span< element_type, dynamic_extent > cetl::pf20::span< T, dynamic_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

operator=() [1/2]

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

constexprdefaultnoexcept

Default assignment operator.

Parameters

rhs	Right-hand-side of the assignment expression.

Returns

reference to *this

See also

std::span::operator=()

operator=() [2/2]

template<typename T>

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

constexprdefaultnoexcept

Default assignment operator.

Parameters

rhs	Right-hand-side of the assignment expression.

Returns

reference to *this

See also

std::span::operator=()

operator[]() [1/2]

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[]()

operator[]() [2/2]

template<typename T>

reference cetl::pf20::span< T, dynamic_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 data(), and span().

rbegin() [1/2]

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

rbegin() [2/2]

template<typename T>

reverse_iterator cetl::pf20::span< T, dynamic_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

rend() [1/2]

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

rend() [2/2]

template<typename T>

reverse_iterator cetl::pf20::span< T, dynamic_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

size() [1/2]

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

size() [2/2]

template<typename T>

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

inlineconstexprnoexcept

Returns the size of the span.

Returns

The number of elements in the span.

See also

std::span::size

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

Here is the caller graph for this function:

size_bytes() [1/2]

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

size_bytes() [2/2]

template<typename T>

size_type cetl::pf20::span< T, dynamic_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/4]

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()

subspan() [2/4]

template<typename T>

template<size_type Offset, size_type Count = dynamic_extent>

span< element_type, Count > cetl::pf20::span< T, dynamic_extent >::subspan ( ) const

inlineconstexpr

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

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.

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 new Extent is Count if that parameter was not dynamic_extent otherwise the new span's Extent is dynamic_extent.

See also

std::span::subspan()

References extent, and subspan().

Referenced by subspan(), and subspan().

Here is the caller graph for this function:

subspan() [3/4]

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()

subspan() [4/4]

template<typename T>

span< element_type, dynamic_extent > cetl::pf20::span< T, dynamic_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 size(), and subspan().

Member Data Documentation

extent [1/2]

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

staticconstexpr

The value of Extent for this template instantiation.

extent [2/2]

template<typename T>

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

staticconstexpr

The value of Extent for this template instantiation.

Referenced by subspan().

---

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

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