ptr_vector.hpp

Go to the documentation of this file.

 
/*
 * This file is part of Algorithms library toolkit.
 * Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
 
 * Algorithms library toolkit is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 
 * Algorithms library toolkit is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 
 * You should have received a copy of the GNU General Public License
 * along with Algorithms library toolkit.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <compare>
 
#include <ext/ostream>
 
#include <extensions/range.hpp>
#include <extensions/clone.hpp>
#include <extensions/container/vector.hpp>
 
namespace ext {
 
template < class T >
class ptr_vector {
    ext::vector < T * > m_data;
 
public:
    using value_type = T;
 
    using size_type = std::size_t;
 
    using diference_type = std::ptrdiff_t;
 
    using reference = value_type &;
 
    using const_reference = const value_type &;
 
    using pointer = T *;
 
    using const_pointer = const T *;
 
    using iterator = dereferencing_iterator < typename std::vector < T * >::iterator >;
 
    using const_iterator = dereferencing_iterator < typename std::vector < T * >::const_iterator >;
 
    using reverse_iterator = dereferencing_iterator < typename std::vector < T * >::reverse_iterator >;
 
    using const_reverse_iterator = dereferencing_iterator < typename std::vector < T * >::const_reverse_iterator >;
 
    ptr_vector ( ) noexcept = default;
 
    template < class R >
    ptr_vector ( std::initializer_list < R > init ) {
        insert ( cbegin ( ), std::move ( init ) );
    }
 
    template < class R = T >
    explicit ptr_vector ( size_type count ) {
        resize < R > ( count );
    }
 
    template < class InputIt >
    ptr_vector ( InputIt first, InputIt last ) {
        insert ( cbegin ( ), first, last );
    }
 
    template < class Iterator >
    ptr_vector ( const ext::iterator_range < Iterator > & range ) : ptr_vector ( range.begin ( ), range.end ( ) ) {
    }
 
    template < class R >
    ptr_vector ( size_type count, const R & value ) {
        insert ( cbegin ( ), count, value );
    }
 
    ptr_vector ( const ptr_vector& other ) {
        insert ( cbegin ( ), other.begin ( ), other.end ( ) );
    }
 
    ptr_vector ( ptr_vector && other ) noexcept {
        std::swap ( m_data, other.m_data );
    }
 
    ~ptr_vector ( ) noexcept {
        clear ( );
    }
 
    ptr_vector < T > & operator = ( const ptr_vector < T > & other ) {
        if ( this == & other )
            return * this;
 
        assign ( other.begin ( ), other.end ( ) );
 
        return *this;
    }
 
    ptr_vector < T > & operator = ( ptr_vector < T > && other ) noexcept {
        std::swap ( m_data, other.m_data );
 
        return *this;
    }
 
    template < class R >
    void assign ( size_type count, const R & value ) {
        clear ( );
        insert ( cbegin ( ), count, value );
    }
 
    template< class InputIt >
    void assign ( InputIt first, InputIt last ) {
        clear ( );
        insert ( cbegin ( ), first, last );
    }
 
    template < class R >
    void assign ( std::initializer_list < R > ilist ) {
        clear ( );
        insert ( cbegin ( ), std::move ( ilist ) );
    }
 
    reference at ( size_type index ) {
        return * m_data.at ( index );
    }
 
    const_reference at ( size_type index ) const {
        return * m_data.at ( index );
    }
 
    reference operator [ ] ( size_type index ) {
        return * m_data [ index ];
    }
 
    const_reference operator [ ] ( size_type index ) const {
        return * m_data [ index ];
    }
 
    reference front ( ) {
        return * m_data.front ( );
    }
 
    const_reference front ( ) const {
        return * m_data.front ( );
    }
 
    reference back ( ) {
        return * m_data.back ( );
    }
 
    const_reference back ( ) const {
        return * m_data.back ( );
    }
 
    iterator begin ( ) & noexcept {
        return dereferencer ( m_data.begin ( ) );
    }
 
    const_iterator begin ( ) const & noexcept {
        return dereferencer ( m_data.begin ( ) );
    }
 
    auto begin ( ) && noexcept {
        return make_move_iterator ( this->begin ( ) );
    }
 
    const_iterator cbegin ( ) const noexcept {
        return dereferencer ( m_data.cbegin ( ) );
    }
 
    iterator end ( ) & noexcept {
        return dereferencer ( m_data.end ( ) );
    }
 
    const_iterator end ( ) const & noexcept {
        return dereferencer ( m_data.end ( ) );
    }
 
    auto end ( ) && noexcept {
        return make_move_iterator ( this->end ( ) );
    }
 
    const_iterator cend ( ) const noexcept {
        return dereferencer ( m_data.cend ( ) );
    }
 
    reverse_iterator rbegin ( ) noexcept {
        return dereferencer ( m_data.rbegin ( ) );
    }
 
    const_reverse_iterator rbegin ( ) const noexcept {
        return dereferencer ( m_data.rbegin ( ) );
    }
 
    const_reverse_iterator crbegin ( ) const noexcept {
        return dereferencer ( m_data.crbegin ( ) );
    }
 
    reverse_iterator rend ( ) noexcept {
        return dereferencer ( m_data.rend ( ) );
    }
 
    const_reverse_iterator rend ( ) const noexcept {
        return dereferencer ( m_data.rend ( ) );
    }
 
    const_reverse_iterator crend ( ) const noexcept {
        return dereferencer ( m_data.crend ( ) );
    }
 
    auto range ( ) & {
        auto endIter = end ( );
        auto beginIter = begin ( );
        return ext::iterator_range < decltype ( endIter ) > ( beginIter, endIter );
    }
 
    auto range ( ) const & {
        auto endIter = end ( );
        auto beginIter = begin ( );
        return ext::iterator_range < decltype ( endIter ) > ( beginIter, endIter );
    }
 
    auto range ( ) && {
        auto endIter = std::move ( * this ).end ( );
        auto beginIter = std::move ( * this ).begin ( );
        return ext::iterator_range < decltype ( endIter ) > ( beginIter, endIter );
    }
 
    bool empty ( ) const noexcept {
        return m_data.empty ( );
    }
 
    size_type size ( ) const noexcept {
        return m_data.size ( );
    }
 
    size_type max_size ( ) const noexcept {
        return m_data.max_size ( );
    }
 
    void reserve ( size_type new_cap ) {
        m_data.reserve ( new_cap );
    }
 
    size_type capacity ( ) const noexcept {
        return m_data.capacity ( );
    }
 
    void shrink_to_fit ( ) {
        m_data.shrink_to_fit ( );
    }
 
    void clear ( ) noexcept {
        for ( T * data : m_data ) {
            delete data;
        }
        m_data.clear ( );
    }
 
    template < class R >
    iterator set ( iterator pos, R && value ) {
        return set ( const_iterator ( pos ), std::forward < R > ( value ) );
    }
 
    template < class R >
    iterator set ( const_iterator pos, R && value ) {
        size_type dist = std::distance ( cbegin ( ), pos );
 
        // If the set value and value at position pos are same instances first clone, then delete
        delete std::exchange ( m_data.at ( dist ), ext::clone ( std::forward < R > ( value ) ) );
 
        return dereferencer ( m_data.begin ( ) + dist );
    }
 
    template < class R >
    reverse_iterator set ( reverse_iterator pos, R && value ) {
        return set ( const_reverse_iterator ( pos ), std::forward < R > ( value ) );
    }
 
    template < class R >
    reverse_iterator set ( const_reverse_iterator pos, R && value ) {
        size_type dist = std::distance ( crbegin ( ), pos );
 
        // If the set value and value at position pos are same instances first clone, then delete
        delete std::exchange ( m_data.at ( m_data.size ( ) - dist - 1 ), ext::clone ( std::forward < R > ( value ) ) );
 
        return dereferencer ( m_data.rbegin ( ) + dist );
    }
 
    template < class R = T, class ... Args >
    iterator emplace_set ( iterator pos, Args && ... args ) {
        return emplace_set ( const_iterator ( pos ), std::forward < Args > ( args ) ... );
    }
 
    template < class R = T, class ... Args >
    iterator emplace_set ( const_iterator pos, Args && ... args ) {
        return set ( pos, R ( std::forward < Args > ( args ) ... ) );
    }
 
    template < class R = T, class ... Args >
    reverse_iterator emplace_set ( reverse_iterator pos, Args && ... args ) {
        return emplace_set ( const_reverse_iterator ( pos ), std::forward < Args > ( args ) ... );
    }
 
    template < class R = T, class ... Args >
    reverse_iterator emplace_set ( const_reverse_iterator pos, Args && ... args ) {
        return set ( pos, R ( std::forward < Args > ( args ) ... ) );
    }
 
    template < class R >
    iterator insert ( iterator pos, R && value ) {
        return insert ( const_insert ( pos ), std::forward < R > ( value ) );
    }
 
    template < class R >
    iterator insert ( const_iterator pos, R && value ) {
        return dereferencer ( m_data.insert ( pos.base ( ), ext::clone ( std::forward < R > ( value ) ) ) );
    }
 
    template < class R >
    reverse_iterator insert ( reverse_iterator pos, R && value ) {
        return insert ( const_reverse_iterator ( pos ), std::forward < R > ( value ) );
    }
 
    template < class R >
    reverse_iterator insert ( const_reverse_iterator pos, R && value ) {
        return dereferencer ( m_data.insert ( pos.base ( ), ext::clone ( std::forward < R > ( value ) ) ) );
    }
 
    template < class R >
    iterator insert ( iterator pos, size_type count, const R & value ) {
        return insert ( const_iterator ( pos ), count, value );
    }
 
    template < class R >
    iterator insert ( const_iterator pos, size_type count, const R & value ) {
        iterator res = dereferencer ( m_data.insert ( pos.base ( ), count, nullptr ) );
        for ( size_type i = 0; i < count; ++ i ) {
            * ( res.base ( ) + i ) = ext::clone ( value );
        }
        return res;
    }
 
    template < class R >
    reverse_iterator insert ( reverse_iterator pos, size_type count, const R & value ) {
        return insert ( const_reverse_iterator ( pos ), count, value );
    }
 
    template < class R >
    reverse_iterator insert ( const_reverse_iterator pos, size_type count, const R & value ) {
        reverse_iterator res = dereferencer ( m_data.insert ( pos, count, nullptr ) );
        for ( size_type i = 0; i < count; ++ i ) {
            * ( std::next ( res.base ( ) ).base ( ) + i ) = ext::clone ( value );
        }
        return res;
    }
 
    template < class InputIt >
    iterator insert ( iterator pos, InputIt first, InputIt last ) {
        return insert ( const_iterator ( pos ), first, last );
    }
 
    template < class InputIt >
    iterator insert ( const_iterator pos, InputIt first, InputIt last ) {
        size_type size = std::distance ( first, last );
        iterator res = dereferencer ( m_data.insert ( pos.base ( ), size, nullptr ) );
 
        for ( size_type i = 0; i < size; ++ first, ++ i )
            * ( res.base ( ) + i ) = ext::clone ( * first );
 
        return res;
    }
 
    template < class InputIt >
    reverse_iterator insert ( reverse_iterator pos, InputIt first, InputIt last ) {
        return insert ( const_reverse_iterator ( pos ), first, last );
    }
 
    template < class InputIt >
    reverse_iterator insert ( const_reverse_iterator pos, InputIt first, InputIt last ) {
        size_type size = std::distance ( first, last );
        reverse_iterator res = dereferencer ( m_data.insert ( pos, size, nullptr ) );
 
        for ( size_type i = 0; i < size; ++ first, ++ i )
            * ( std::next ( res.base ( ) ).base ( ) + i ) = ext::clone ( * first );
 
        return res;
    }
 
    template < class R >
    iterator insert ( iterator pos, std::initializer_list < R > ilist ) {
        return insert ( const_iterator ( pos ), std::move ( ilist ) );
    }
 
    template < class R >
    iterator insert ( const_iterator pos, std::initializer_list < R > ilist ) {
        return insert ( pos, ilist.begin ( ), ilist.end ( ) );
    }
 
    template < class R >
    reverse_iterator insert ( reverse_iterator pos, std::initializer_list < R > ilist ) {
        return insert ( const_reverse_iterator ( pos ), std::move ( ilist ) );
    }
 
    template < class R >
    reverse_iterator insert ( const_reverse_iterator pos, std::initializer_list < R > ilist ) {
        return insert ( pos, ilist.begin ( ), ilist.end ( ) );
    }
 
    template < class R = T, class ... Args >
    iterator emplace ( iterator pos, Args && ... args ) {
        return emplace ( const_iterator ( pos ), std::forward < Args > ( args ) ... );
    }
 
    template < class R = T, class ... Args >
    iterator emplace ( const_iterator pos, Args && ... args ) {
        return insert ( pos, R ( std::forward < Args > ( args ) ... ) );
    }
 
    template < class R = T, class ... Args >
    reverse_iterator emplace ( reverse_iterator pos, Args && ... args ) {
        return emplace ( const_reverse_iterator ( pos ), std::forward < Args > ( args ) ... );
    }
 
    template < class R = T, class ... Args >
    reverse_iterator emplace ( const_reverse_iterator pos, Args && ... args ) {
        return insert ( pos, R ( std::forward < Args > ( args ) ... ) );
    }
 
    iterator erase ( iterator pos ) {
        return erase ( const_iterator ( pos ) );
    }
 
    iterator erase ( const_iterator pos ) {
        delete std::addressof ( * pos );
        return dereferencer ( m_data.erase ( pos.base ( ) ) );
    }
 
    reverse_iterator erase ( reverse_iterator pos ) {
        return erase ( const_reverse_iterator ( pos ) );
    }
 
    reverse_iterator erase ( const_reverse_iterator pos ) {
        delete std::addressof ( * pos );
        return dereferencer ( m_data.erase ( pos.base ( ) ) );
    }
 
    iterator erase ( iterator first, iterator last ) {
        return erase ( const_iterator ( first ), const_iterator ( last ) );
    }
 
    iterator erase ( const_iterator first, const_iterator last ) {
        for ( const_iterator first_copy = first; first_copy != last; ++ first_copy ) {
            delete std::addressof ( * first_copy );
        }
        return dereferencer ( m_data.erase ( first.base ( ), last.base ( ) ) );
    }
 
    reverse_iterator erase ( reverse_iterator first, reverse_iterator last ) {
        return erase ( const_reverse_iterator ( first ), const_reverse_iterator ( last ) );
    }
 
    reverse_iterator erase ( const_reverse_iterator first, const_reverse_iterator last ) {
        for ( const_reverse_iterator first_copy = first; first_copy != last; ++ first_copy ) {
            delete std::addressof ( * first_copy );
        }
        return dereferencer ( m_data.erase ( first.base ( ), last.base ( ) ) );
    }
 
    template < class R >
    void push_back ( R && value ) {
        insert ( cend ( ), std::forward < R > ( value ) );
    }
 
    template < class R = T, class ... Args >
    reference emplace_back ( Args && ... args ) {
        return * emplace < R > ( cend ( ), std::forward < Args > ( args ) ... );
    }
 
    void pop_back ( ) {
        delete m_data.back ( );
        m_data.pop_back ( );
    }
 
    template < class R = T >
    void resize ( size_type count ) {
        for ( size_type i = count; i < m_data.size ( ); ++ i ) {
            delete m_data [ i ];
        }
        size_type i = m_data.size ( );
        m_data.resize ( count );
        for ( ; i < count; ++ i ) {
            m_data [ i ] = new R ( );
        }
    }
 
    template < class R >
    void resize ( size_type count, const R & value ) {
        for ( size_type i = count; i < m_data.size ( ); ++ i ) {
            delete m_data [ i ];
        }
        size_type i = m_data.size ( );
        m_data.resize ( count );
        for ( ; i < count; ++ i ) {
            m_data [ i ] = ext::clone ( value );
        }
    }
 
    void shrink ( size_type count ) {
        for ( size_type i = count; i < m_data.size ( ); ++ i ) {
            delete m_data [ i ];
        }
        m_data.resize ( std::min ( count, m_data.size ( ) ) );
    }
 
    void swap ( ptr_vector & other ) {
        std::swap ( this->m_data, other.m_data );
    }
 
    auto operator <=> ( const ext::ptr_vector < T > & second) const {
        const ptr_vector < T > & first = * this;
        return std::lexicographical_compare_three_way ( first.begin ( ), first.end ( ), second.begin ( ), second.end ( ) );
    }
 
    bool operator == ( const ptr_vector < T > & second ) const {
        const ptr_vector < T > & first = * this;
        return std::equal ( first.begin ( ), first.end ( ), second.begin ( ), second.end ( ) );
    }
 
};
 
template< class T >
ext::ostream& operator<<(ext::ostream& out, const ext::ptr_vector < T > & ptr_vector) {
    out << "[";
 
    bool first = true;
    for(const T& item : ptr_vector) {
        if(!first) out << ", ";
        first = false;
        out << item;
    }
 
    out << "]";
    return out;
}
 
} /* namespace ext */