view.h

Go to the documentation of this file.

 
#pragma once
 
#include "./types.h"
 
#include <span>
 
namespace emlabcpp
{
 
template < typename Iterator, typename EndIterator = Iterator >
class view
{
        Iterator    begin_;
        EndIterator end_;
 
public:
        using value_type       = typename std::iterator_traits< Iterator >::value_type;
        using reverse_iterator = std::reverse_iterator< Iterator >;
        using iterator         = Iterator;
        using difference_type  = typename std::iterator_traits< Iterator >::difference_type;
        using size_type        = std::size_t;
 
        constexpr view() = default;
 
        template < range_container_with_iter< iterator > Cont >
        constexpr view( Cont& cont )
          : begin_( std::begin( cont ) )
          , end_( std::end( cont ) )
        {
        }
 
        template < range_container_with_iter< iterator > Cont >
        constexpr view( Cont const& cont )
          : begin_( std::begin( cont ) )
          , end_( std::end( cont ) )
        {
        }
 
        template < data_container_with_iter< iterator > Cont >
        requires( !range_container_with_iter< Cont, iterator > )
        constexpr view( Cont& cont )
          : begin_( std::data( cont ) )
          , end_( begin_ + std::size( cont ) )
        {
        }
 
        template < data_container_with_iter< iterator > Cont >
        requires( !range_container_with_iter< Cont, iterator > )
        constexpr view( Cont const& cont )
          : begin_( std::data( cont ) )
          , end_( begin_ + std::size( cont ) )
        {
        }
 
        constexpr view( Iterator begin, EndIterator end )
          : begin_( std::move( begin ) )
          , end_( std::move( end ) )
        {
        }
 
        template <
            std::convertible_to< Iterator >    OtherIterator,
            std::convertible_to< EndIterator > OtherEndIterator >
        constexpr view( view< OtherIterator, OtherEndIterator > other )
          : begin_( other.begin() )
          , end_( other.end() )
        {
        }
 
        [[nodiscard]] constexpr Iterator begin() const
        {
                return begin_;
        }
 
        [[nodiscard]] constexpr EndIterator end() const
        {
                return end_;
        }
 
        [[nodiscard]] constexpr decltype( auto ) operator[]( size_type const i ) const
        {
                return *( begin_ + static_cast< difference_type >( i ) );
        }
 
        [[nodiscard]] constexpr reverse_iterator rbegin() const
        {
                return reverse_iterator{ end_ };
        }
 
        [[nodiscard]] constexpr reverse_iterator rend() const
        {
                return reverse_iterator{ begin_ };
        }
 
        [[nodiscard]] constexpr size_type size() const
        {
                return static_cast< std::size_t >( std::ranges::distance( begin(), end() ) );
        }
 
        [[nodiscard]] constexpr bool empty() const
        {
                return begin() == end();
        }
 
        [[nodiscard]] constexpr value_type const& front() const
        {
                return *begin_;
        }
 
        [[nodiscard]] constexpr value_type const& back() const
        {
                return *std::prev( end_ );
        }
 
        operator std::span< value_type >()
        {
                return std::span{ begin(), end() };
        }
};
 
template < typename IteratorLh, typename IteratorRh >
constexpr bool operator==( view< IteratorLh > const& lh, view< IteratorRh > const& rh )
{
        if ( lh.size() != rh.size() )
                return false;
 
        IteratorLh lhiter = lh.begin();
        IteratorRh rhiter = rh.begin();
 
        for ( ; lhiter != lh.end(); ++lhiter, ++rhiter )
                if ( *lhiter != *rhiter )
                        return false;
        return true;
}
 
template < typename IteratorLh, typename IteratorRh >
constexpr bool operator!=( view< IteratorLh > const& lh, view< IteratorRh > const& rh )
{
        return !( lh == rh );
}
 
template < range_container Container >
view( Container& cont ) -> view< iterator_of_t< Container > >;
 
template < typename Iter >
struct impl::is_view< view< Iter > > : std::true_type
{
};
 
template < typename Iter >
constexpr view< Iter > view_n( Iter begin, std::size_t const n )
{
        auto end = std::next(
            begin, static_cast< typename std::iterator_traits< Iter >::difference_type >( n ) );
        return view< Iter >{ std::move( begin ), end };
}
 
template < data_container Container >
constexpr auto data_view( Container& cont )
{
        return view_n( std::data( cont ), std::size( cont ) );
}
 
template < range_container Container >
constexpr view< iterator_of_t< Container > > trim_view( Container& cont, float const r )
{
        std::size_t const step = std::size( cont ) * ( 1.f - r ) / 2.f;
        return { std::begin( cont ) + step, std::end( cont ) - step };
}
 
constexpr auto
reversed( referenceable_container auto& container ) -> view< decltype( std::rbegin( container ) ) >
{
        return { std::rbegin( container ), std::rend( container ) };
}
 
template < typename Iterator, typename EndIterator >
void string_serialize_view( auto&& w, view< Iterator, EndIterator > const& output )
{
        using value_type = typename std::iterator_traits< Iterator >::value_type;
        bool first       = true;
        for ( value_type const& item : output ) {
                if ( !first )
                        w( ',' );
                w( item );
                first = false;
        }
}
 
#ifdef EMLABCPP_USE_OSTREAM
 
template < typename Iterator, typename EndIterator >
std::ostream& operator<<( std::ostream& os, view< Iterator, EndIterator > const& iter )
{
        static_assert( ostreamable< typename std::iterator_traits< Iterator >::value_type > );
        string_serialize_view(
            [&os]( auto const& item ) {
                    os << item;
            },
            iter );
        return os;
}
#endif
 
}  // namespace emlabcpp