ptr_array.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 <ostream>
#include <compare>
 
#include <ext/ostream>
#include <ext/array>
 
#include <extensions/range.hpp>
#include <extensions/clone.hpp>
 
namespace ext {
 
template < class T, std::size_t N >
class ptr_array {
    std::array < T *, N > 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::array < T *, N >::iterator >;
 
    using const_iterator = dereferencing_iterator < typename std::array < T *, N >::const_iterator >;
 
    using reverse_iterator = dereferencing_iterator < typename std::array < T *, N >::reverse_iterator >;
 
    using const_reverse_iterator = dereferencing_iterator < typename std::array < T *, N >::const_reverse_iterator >;
 
    template < class ... Types >
    ptr_array ( Types && ... args ) : m_data ( make_array < T * > ( ext::clone ( std::forward < Types > ( args ) ) ... ) ) {
    }
 
    template < class R = T >
    ptr_array ( ) {
        if constexpr ( N != 0 )
            for ( size_type i = 0; i < N; ++ i )
                m_data.at ( i ) = new R ( );
    }
 
    ptr_array ( const ptr_array & other ) {
        if constexpr ( N != 0 )
            for ( size_type i = 0; i < N; ++ i )
                m_data.at ( i ) = ext::clone ( other.at ( i ) );
    }
 
    ptr_array ( ptr_array && other ) noexcept {
        if constexpr ( N != 0 )
            for ( size_type i = 0; i < N; ++ i )
                m_data.at ( i ) = std::exchange ( other.m_data.at ( i ), nullptr );
    }
 
    ~ptr_array ( ) noexcept {
        if constexpr ( N != 0 )
            for ( size_type i = 0; i < N; ++ i )
                delete m_data.at ( i );
    }
 
    ptr_array < T, N > & operator = ( const ptr_array < T, N > & other ) {
        if ( this == & other )
            return * this;
 
        if constexpr ( N != 0 )
            for ( size_type i = 0; i < N; ++ i ) {
                delete m_data.at ( i );
                m_data.at ( i ) = ext::clone ( other.at ( i ) );
            }
 
        return *this;
    }
 
    ptr_array < T, N > & operator = ( ptr_array < T, N > && other ) noexcept {
        std::swap ( m_data, other.m_data );
 
        return *this;
    }
 
    template < class R >
    void fill ( const R & value ) {
        if constexpr ( N != 0 )
            for ( size_type i = 0; i < N; ++ i )
                m_data.at ( i ) = ext::clone ( value );
    }
 
    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 ( );
    }
 
    bool null ( size_type index ) const {
        return m_data.at ( index ) == nullptr;
    }
 
    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->end ( ) );
    }
 
    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 ( );
    }
 
    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 >
    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, class ... Args >
    iterator emplace_set ( const_iterator pos, Args && ... args ) {
        return set ( pos, R ( std::forward < Args > ( args ) ... ) );
    }
 
    template < class R, class ... Args >
    iterator emplace_set ( const_reverse_iterator pos, Args && ... args ) {
        return set ( pos, R ( std::forward < Args > ( args ) ... ) );
    }
 
    void swap ( ptr_array & other ) {
        swap ( this->m_data, other.m_data );
    }
 
    template < std::size_t I >
    auto & get ( ) & {
        return * std::get < I > ( m_data );
    }
 
    template < std::size_t I >
    const auto & get ( ) const & {
        return * std::get < I > ( m_data );
    }
 
    template < std::size_t I >
    auto && get ( ) && {
        return std::move ( * std::get < I > ( m_data ) );
    }
 
    auto operator <=> (const ext::ptr_array < T, N > & second) const {
        const ext::ptr_array < T, N > & first = * this;
        return std::lexicographical_compare_three_way ( first.begin ( ), first.end ( ), second.begin ( ), second.end ( ) );
    }
 
    bool operator == (const ext::ptr_array < T, N > & second) const {
        const ext::ptr_array < T, N > & first = * this;
        return std::equal ( first.begin ( ), first.end ( ), second.begin ( ), second.end ( ) );
    }
 
};
 
} /* namespace ext */
 
namespace std {
 
template < std::size_t I, class Type, std::size_t N >
auto & get ( ext::ptr_array < Type, N > & tpl ) {
    return tpl.template get < I > ( );
}
 
template < std::size_t I, class Type, std::size_t N >
const auto & get ( const ext::ptr_array < Type, N > & tpl ) {
    return tpl.template get < I > ( );
}
 
template < std::size_t I, class Type, std::size_t N >
auto && get ( ext::ptr_array < Type, N > && tpl ) {
    return std::move ( tpl ).template get < I > ( );
}
 
} /* namespace std */
 
namespace ext {
 
template < class T, std::size_t N >
ext::ostream& operator<<(ext::ostream& out, const ext::ptr_array < T, N > & ptr_array) {
    out << "[";
 
    bool first = true;
    for(const T& item : ptr_array) {
        if(!first) out << ", ";
        first = false;
        out << item;
    }
 
    out << "]";
    return out;
}
 
template < typename Base, typename ... Types >
constexpr ptr_array < typename std::remove_reference < Base >::type , sizeof ... ( Types ) + 1 > make_ptr_array ( Base && first, Types && ... other ) {
    return ptr_array < typename std::remove_reference < Base >::type, sizeof ... ( Types ) + 1 > ( std::forward < Base > ( first ), std::forward < Types > ( other ) ... );
}
 
template < typename Base >
constexpr ptr_array < typename std::remove_reference < Base >::type, 0 > make_ptr_array ( ) {
    return ptr_array < typename std::remove_reference < Base >::type, 0 > ( );
}
 
} /* namespace ext */