bsl::reverse_iterator< Iter > Class Template Reference

Provides a reverse iterator as defined by the C++ specification, with the follwing differences: More...

#include <reverse_iterator.hpp>

Public Types
using	value_type = typename Iter::value_type
	alias for: typename Iter::value_type
using	size_type = bsl::uintmax
	alias for: bsl::uintmax
using	difference_type = bsl::uintmax
	alias for: bsl::uintmax
using	reference_type = typename Iter::value_type &
	alias for: typename Iter::value_type &
using	const_reference_type = typename Iter::value_type const &
	alias for: typename Iter::value_type const &
using	pointer_type = typename Iter::value_type *
	alias for: typename Iter::value_type *
using	const_pointer_type = typename Iter::value_type const *
	alias for: typename Iter::value_type const *

Public Member Functions
constexpr	reverse_iterator (Iter const &i) noexcept
	Creates a reverse iterator given a an iterator to reverse. It should be noted that you should not call this directly, but instead should call rbegin() or rend() for your given container. More...
constexpr Iter	base () const noexcept
	Returns a pointer to the array being iterated. More...
constexpr pointer_type	data () noexcept
	Returns a pointer to the array being iterated. More...
constexpr const_pointer_type	data () const noexcept
	Returns a pointer to the array being iterated. More...
constexpr size_type	size () const noexcept
	Returns the number of elements in the array being iterated. More...
constexpr size_type	index () const noexcept
	Returns the iterator's current index. If the iterator is at the end, this function returns size(). More...
constexpr bool	empty () const noexcept
	Returns nullptr == data() More...
constexpr bool	is_end () const noexcept
	Returns index() == 0. More...
constexpr pointer_type	get_if () noexcept
	Returns a pointer to the instance of T stored at the iterator's current index. If the index is out of bounds, or the iterator is invalid, this function returns a nullptr. More...
constexpr reverse_iterator &	operator++ () noexcept
	Increments the iterator. More...
constexpr reverse_iterator &	operator-- () noexcept
	Decrements the iterator. More...

Related Functions
(Note that these are not member functions.)
template<typename T >
constexpr bool	operator== (reverse_iterator< T > const &lhs, reverse_iterator< T > const &rhs) noexcept
	Returns lhs.base() == rhs.base() More...
template<typename T >
constexpr bool	operator!= (reverse_iterator< T > const &lhs, reverse_iterator< T > const &rhs) noexcept
	Returns lhs.base() != rhs.base() More...
template<typename T >
constexpr bool	operator< (reverse_iterator< T > const &lhs, reverse_iterator< T > const &rhs) noexcept
	Returns lhs.base() < rhs.base() More...
template<typename T >
constexpr bool	operator<= (reverse_iterator< T > const &lhs, reverse_iterator< T > const &rhs) noexcept
	Returns lhs.base() <= rhs.base() More...
template<typename T >
constexpr bool	operator> (reverse_iterator< T > const &lhs, reverse_iterator< T > const &rhs) noexcept
	Returns lhs.base() > rhs.base() More...
template<typename T >
constexpr bool	operator>= (reverse_iterator< T > const &lhs, reverse_iterator< T > const &rhs) noexcept
	Returns lhs.base() >= rhs.base() More...
template<typename Iter >
constexpr reverse_iterator< Iter >	make_reverse_iterator (Iter const &i) noexcept
	Constructs a reverse_iterator for a given provided iterator. More...

Detailed Description

template<typename Iter>
class bsl::reverse_iterator< Iter >

Provides a reverse iterator as defined by the C++ specification, with the follwing differences:

• The difference type that we use is a bsl::uintmax instead of a signed type, which causes a lot of problems with AUTOSAR compliance as signed/unsigned conversions and overflow are a huge problem with the standard library. This iterator type is used by all of the "view" type containers including the bsl::span, bsl::array and bsl::string_view
• We do not provide any of the *, -> or [] accessors as none of these accessors are compliant with AUTOSAR. Instead, we provide a get_if() function, which returns a pointer to the element being accessed by the iterator, or a nullptr if the iterator is invalid or is the same as end(). As a result, ranged based for loops are not supported, and instead, use a view's for_each function which will perform the same action, with less overhead, and better safety.
• The iterator is always inbounds, equal to end() or is invalid. Traditional iterators can be anything, they can overrun, underrun, and everyting in between. If this iterator is valid, the index is always bounded by the size of the array it is pointing to, or is equal to end(). Wrapping, overruns, and underruns are not possible.
• We do not provide the protected member "current" as this class cannot be subclassed.

  
  #include <bsl/string_view.hpp>
  #include <bsl/for_each.hpp>
  #include <bsl/debug.hpp>
  
  namespace bsl
  {
      inline void
      example_reverse_iterator_overview() noexcept
      {
          constexpr bsl::string_view str{"Hello"};
          bsl::for_each(str.rbegin(), str.rend(), [](auto &e) noexcept {
              bsl::print() << e;
          });
  
          bsl::print() << bsl::endl;
      }
  }

Template Parameters

Iter	The type of iterator to reverse

Constructor & Destructor Documentation

reverse_iterator()

template<typename Iter>

constexpr bsl::reverse_iterator< Iter >::reverse_iterator ( Iter const &  i )

inlineexplicitnoexcept

Creates a reverse iterator given a an iterator to reverse. It should be noted that you should not call this directly, but instead should call rbegin() or rend() for your given container.

Parameters

i	the iterator to use

Member Function Documentation

base()

template<typename Iter>

constexpr Iter bsl::reverse_iterator< Iter >::base ( ) const

inlinenoexcept

Returns a pointer to the array being iterated.

#include <bsl/string_view.hpp>
#include <bsl/debug.hpp>

namespace bsl
{
    inline void
    example_reverse_iterator_data() noexcept
    {
        constexpr bsl::string_view str{"Hello"};
        constexpr bsl::string_view::reverse_iterator_type iter{str.rbegin()};

        if (str.data() == iter.data()) {
            bsl::print() << "success\n";
        }
    }
}

Returns

Returns a pointer to the array being iterated

data() [1/2]

template<typename Iter>

constexpr pointer_type bsl::reverse_iterator< Iter >::data ( )

inlinenoexcept

Returns a pointer to the array being iterated.

#include <bsl/string_view.hpp>
#include <bsl/debug.hpp>

namespace bsl
{
    inline void
    example_reverse_iterator_data() noexcept
    {
        constexpr bsl::string_view str{"Hello"};
        constexpr bsl::string_view::reverse_iterator_type iter{str.rbegin()};

        if (str.data() == iter.data()) {
            bsl::print() << "success\n";
        }
    }
}

Returns

Returns a pointer to the array being iterated

data() [2/2]

template<typename Iter>

constexpr const_pointer_type bsl::reverse_iterator< Iter >::data ( ) const

inlinenoexcept

Returns a pointer to the array being iterated.

#include <bsl/string_view.hpp>
#include <bsl/debug.hpp>

namespace bsl
{
    inline void
    example_reverse_iterator_data() noexcept
    {
        constexpr bsl::string_view str{"Hello"};
        constexpr bsl::string_view::reverse_iterator_type iter{str.rbegin()};

        if (str.data() == iter.data()) {
            bsl::print() << "success\n";
        }
    }
}

Returns

Returns a pointer to the array being iterated

size()

template<typename Iter>

constexpr size_type bsl::reverse_iterator< Iter >::size ( ) const

inlinenoexcept

Returns the number of elements in the array being iterated.

#include <bsl/string_view.hpp>
#include <bsl/debug.hpp>

namespace bsl
{
    inline void
    example_reverse_iterator_size() noexcept
    {
        constexpr bsl::string_view str{"Hello"};
        constexpr bsl::string_view::reverse_iterator_type iter{str.rbegin()};

        if (str.size() == iter.size()) {
            bsl::print() << "success\n";
        }
    }
}

Returns

Returns the number of elements in the array being iterated

index()

template<typename Iter>

constexpr size_type bsl::reverse_iterator< Iter >::index ( ) const

inlinenoexcept

Returns the iterator's current index. If the iterator is at the end, this function returns size().

#include <bsl/string_view.hpp>
#include <bsl/debug.hpp>

namespace bsl
{
    inline void
    example_reverse_iterator_index() noexcept
    {
        constexpr bsl::string_view str{"Hello"};
        constexpr bsl::string_view::reverse_iterator_type iter{str.rbegin()};

        if (0U == iter.index()) {
            bsl::print() << "success\n";
        }
    }
}

Returns

Returns the iterator's current index

empty()

template<typename Iter>

constexpr bool bsl::reverse_iterator< Iter >::empty ( ) const

inlinenoexcept

Returns nullptr == data()

#include <bsl/string_view.hpp>
#include <bsl/debug.hpp>

namespace bsl
{
    inline void
    example_reverse_iterator_empty() noexcept
    {
        constexpr bsl::string_view str{"Hello"};
        constexpr bsl::string_view::reverse_iterator_type iter{str.rbegin()};

        if (!iter.empty()) {
            bsl::print() << "success\n";
        }
    }
}

Returns

Returns nullptr == data()

is_end()

template<typename Iter>

constexpr bool bsl::reverse_iterator< Iter >::is_end ( ) const

inlinenoexcept

Returns index() == 0.

#include <bsl/string_view.hpp>
#include <bsl/debug.hpp>

namespace bsl
{
    inline void
    example_reverse_iterator_is_end() noexcept
    {
        constexpr bsl::string_view str{"Hello"};
        constexpr bsl::string_view::reverse_iterator_type iter{str.rend()};

        if (iter.is_end()) {
            bsl::print() << "success\n";
        }
    }
}

Returns

Returns index() == size()

get_if()

template<typename Iter>

constexpr pointer_type bsl::reverse_iterator< Iter >::get_if ( )

inlinenoexcept

Returns a pointer to the instance of T stored at the iterator's current index. If the index is out of bounds, or the iterator is invalid, this function returns a nullptr.

#include <bsl/string_view.hpp>
#include <bsl/debug.hpp>

namespace bsl
{
    inline void
    example_reverse_iterator_get_if() noexcept
    {
        constexpr bsl::string_view str{"Hello"};
        bsl::string_view::reverse_iterator_type iter{str.rbegin()};

        if (auto const *const ptr = iter.get_if()) {
            bsl::print() << "success: " << *ptr << bsl::endl;
        }
    }
}

SUPPRESSION: PRQA 4024 - false positive

• We suppress this because A9-3-1 states that pointer we should not provide a non-const reference or pointer to private member function, unless the class mimics a smart pointer or a containter. This class mimics a container.

Returns

Returns a pointer to the instance of T stored at the iterator's current index. If the index is out of bounds, or the iterator is invalid, this function returns a nullptr.

operator++()

template<typename Iter>

constexpr reverse_iterator& bsl::reverse_iterator< Iter >::operator++ ( )

inlinenoexcept

Increments the iterator.

#include <bsl/string_view.hpp>
#include <bsl/debug.hpp>

namespace bsl
{
    inline void
    example_reverse_iterator_increment() noexcept
    {
        constexpr bsl::string_view str{"Hello"};
        bsl::string_view::reverse_iterator_type iter{str.rbegin()};

        ++iter;
        if (auto const *const ptr = iter.get_if()) {
            bsl::print() << "success: " << *ptr << bsl::endl;
        }
    }
}

Returns

returns *this

operator--()

template<typename Iter>

constexpr reverse_iterator& bsl::reverse_iterator< Iter >::operator-- ( )

inlinenoexcept

Decrements the iterator.

#include <bsl/string_view.hpp>
#include <bsl/debug.hpp>

namespace bsl
{
    inline void
    example_reverse_iterator_decrement() noexcept
    {
        constexpr bsl::string_view str{"Hello"};
        bsl::string_view::reverse_iterator_type iter{str.rend()};

        --iter;
        if (auto const *const ptr = iter.get_if()) {
            bsl::print() << "success: " << *ptr << bsl::endl;
        }
    }
}

Returns

returns *this

Friends And Related Function Documentation

operator==()

template<typename T >

constexpr bool operator== ( reverse_iterator< T > const &  lhs, reverse_iterator< T > const &  rhs  )

related

Returns lhs.base() == rhs.base()

#include <bsl/string_view.hpp>
#include <bsl/debug.hpp>

namespace bsl
{
    inline void
    example_reverse_iterator_equals() noexcept
    {
        constexpr bsl::string_view str{"Hello"};
        constexpr bsl::string_view::reverse_iterator_type iter1{str.rbegin()};
        constexpr bsl::string_view::reverse_iterator_type iter2{str.rbegin()};
        constexpr bsl::string_view::reverse_iterator_type iter3{str.rend()};

        if (iter1 == iter2) {
            bsl::print() << "success\n";
        }

        if (iter1 != iter3) {
            bsl::print() << "success\n";
        }

        if (iter1 < iter3) {
            bsl::print() << "success\n";
        }

        if (iter1 <= iter2) {
            bsl::print() << "success\n";
        }

        if (iter3 > iter1) {
            bsl::print() << "success\n";
        }

        if (iter3 >= iter1) {
            bsl::print() << "success\n";
        }
    }
}

Template Parameters

T	the type of element being iterated.

Parameters

lhs	the left hand side of the operation
rhs	the rhs hand side of the operation

Returns

Returns lhs.base() == rhs.base()

operator!=()

template<typename T >

constexpr bool operator!= ( reverse_iterator< T > const &  lhs, reverse_iterator< T > const &  rhs  )

related

Returns lhs.base() != rhs.base()

#include <bsl/string_view.hpp>
#include <bsl/debug.hpp>

namespace bsl
{
    inline void
    example_reverse_iterator_not_equals() noexcept
    {
        constexpr bsl::string_view str{"Hello"};
        constexpr bsl::string_view::reverse_iterator_type iter1{str.rbegin()};
        constexpr bsl::string_view::reverse_iterator_type iter2{str.rbegin()};
        constexpr bsl::string_view::reverse_iterator_type iter3{str.rend()};

        if (iter1 == iter2) {
            bsl::print() << "success\n";
        }

        if (iter1 != iter3) {
            bsl::print() << "success\n";
        }

        if (iter1 < iter3) {
            bsl::print() << "success\n";
        }

        if (iter1 <= iter2) {
            bsl::print() << "success\n";
        }

        if (iter3 > iter1) {
            bsl::print() << "success\n";
        }

        if (iter3 >= iter1) {
            bsl::print() << "success\n";
        }
    }
}

Template Parameters

T	the type of element being iterated.

Parameters

lhs	the left hand side of the operation
rhs	the rhs hand side of the operation

Returns

Returns lhs.base() != rhs.base()

operator<()

template<typename T >

constexpr bool operator< ( reverse_iterator< T > const &  lhs, reverse_iterator< T > const &  rhs  )

related

Returns lhs.base() < rhs.base()

#include <bsl/string_view.hpp>
#include <bsl/debug.hpp>

namespace bsl
{
    inline void
    example_reverse_iterator_lt() noexcept
    {
        constexpr bsl::string_view str{"Hello"};
        constexpr bsl::string_view::reverse_iterator_type iter1{str.rbegin()};
        constexpr bsl::string_view::reverse_iterator_type iter2{str.rbegin()};
        constexpr bsl::string_view::reverse_iterator_type iter3{str.rend()};

        if (iter1 == iter2) {
            bsl::print() << "success\n";
        }

        if (iter1 != iter3) {
            bsl::print() << "success\n";
        }

        if (iter1 < iter3) {
            bsl::print() << "success\n";
        }

        if (iter1 <= iter2) {
            bsl::print() << "success\n";
        }

        if (iter3 > iter1) {
            bsl::print() << "success\n";
        }

        if (iter3 >= iter1) {
            bsl::print() << "success\n";
        }
    }
}

Template Parameters

T	the type of element being iterated.

Parameters

lhs	the left hand side of the operation
rhs	the rhs hand side of the operation

Returns

Returns lhs.base() < rhs.base()

operator<=()

template<typename T >

constexpr bool operator<= ( reverse_iterator< T > const &  lhs, reverse_iterator< T > const &  rhs  )

related

Returns lhs.base() <= rhs.base()

#include <bsl/string_view.hpp>
#include <bsl/debug.hpp>

namespace bsl
{
    inline void
    example_reverse_iterator_lt_equals() noexcept
    {
        constexpr bsl::string_view str{"Hello"};
        constexpr bsl::string_view::reverse_iterator_type iter1{str.rbegin()};
        constexpr bsl::string_view::reverse_iterator_type iter2{str.rbegin()};
        constexpr bsl::string_view::reverse_iterator_type iter3{str.rend()};

        if (iter1 == iter2) {
            bsl::print() << "success\n";
        }

        if (iter1 != iter3) {
            bsl::print() << "success\n";
        }

        if (iter1 < iter3) {
            bsl::print() << "success\n";
        }

        if (iter1 <= iter2) {
            bsl::print() << "success\n";
        }

        if (iter3 > iter1) {
            bsl::print() << "success\n";
        }

        if (iter3 >= iter1) {
            bsl::print() << "success\n";
        }
    }
}

Template Parameters

T	the type of element being iterated.

Parameters

lhs	the left hand side of the operation
rhs	the rhs hand side of the operation

Returns

Returns lhs.base() <= rhs.base()

operator>()

template<typename T >

constexpr bool operator> ( reverse_iterator< T > const &  lhs, reverse_iterator< T > const &  rhs  )

related

Returns lhs.base() > rhs.base()

#include <bsl/string_view.hpp>
#include <bsl/debug.hpp>

namespace bsl
{
    inline void
    example_reverse_iterator_gt() noexcept
    {
        constexpr bsl::string_view str{"Hello"};
        constexpr bsl::string_view::reverse_iterator_type iter1{str.rbegin()};
        constexpr bsl::string_view::reverse_iterator_type iter2{str.rbegin()};
        constexpr bsl::string_view::reverse_iterator_type iter3{str.rend()};

        if (iter1 == iter2) {
            bsl::print() << "success\n";
        }

        if (iter1 != iter3) {
            bsl::print() << "success\n";
        }

        if (iter1 < iter3) {
            bsl::print() << "success\n";
        }

        if (iter1 <= iter2) {
            bsl::print() << "success\n";
        }

        if (iter3 > iter1) {
            bsl::print() << "success\n";
        }

        if (iter3 >= iter1) {
            bsl::print() << "success\n";
        }
    }
}

Template Parameters

T	the type of element being iterated.

Parameters

lhs	the left hand side of the operation
rhs	the rhs hand side of the operation

Returns

Returns lhs.base() > rhs.base()

operator>=()

template<typename T >

constexpr bool operator>= ( reverse_iterator< T > const &  lhs, reverse_iterator< T > const &  rhs  )

related

Returns lhs.base() >= rhs.base()

#include <bsl/string_view.hpp>
#include <bsl/debug.hpp>

namespace bsl
{
    inline void
    example_reverse_iterator_gt_equals() noexcept
    {
        constexpr bsl::string_view str{"Hello"};
        constexpr bsl::string_view::reverse_iterator_type iter1{str.rbegin()};
        constexpr bsl::string_view::reverse_iterator_type iter2{str.rbegin()};
        constexpr bsl::string_view::reverse_iterator_type iter3{str.rend()};

        if (iter1 == iter2) {
            bsl::print() << "success\n";
        }

        if (iter1 != iter3) {
            bsl::print() << "success\n";
        }

        if (iter1 < iter3) {
            bsl::print() << "success\n";
        }

        if (iter1 <= iter2) {
            bsl::print() << "success\n";
        }

        if (iter3 > iter1) {
            bsl::print() << "success\n";
        }

        if (iter3 >= iter1) {
            bsl::print() << "success\n";
        }
    }
}

Template Parameters

T	the type of element being iterated.

Parameters

lhs	the left hand side of the operation
rhs	the rhs hand side of the operation

Returns

Returns lhs.base() >= rhs.base()

make_reverse_iterator()

template<typename Iter >

constexpr reverse_iterator< Iter > make_reverse_iterator ( Iter const &  i )

related

Constructs a reverse_iterator for a given provided iterator.

Template Parameters

Iter	the type of iterator to make the reverse iterator from.

Parameters

i	the iterator to make the reverse iterator from.

Returns

a newly constructed reverse iterator.

---

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

• include/bsl/reverse_iterator.hpp