ptr_tuple.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/iterator.hpp>
#include <extensions/clone.hpp>
 
#include <extensions/common/tuple_common.hpp>
 
namespace ext {
 
template < class ... Types >
class ptr_tuple {
    std::tuple < Types * ... > m_data;
 
    template < std::size_t ... Indices >
    void copyCons ( std::index_sequence < Indices ... >, const ptr_tuple & tpl ) {
        ( ( std::get < Indices > ( m_data ) = ext::clone ( std::get < Indices > ( * tpl.m_data ) ) ), ... );
    }
 
    template < std::size_t ... Indices >
    void moveCons ( std::index_sequence < Indices ... >, ptr_tuple && tpl ) {
        ( std::swap ( std::get < Indices > ( m_data ), std::get < Indices > ( tpl.m_data ) ), ... );
    }
 
    template < std::size_t ... Indices, class ... UTypes >
    void cons ( std::index_sequence < Indices ... >, UTypes && ... elems ) {
        ( ( std::get < Indices > ( m_data ) = ext::clone ( std::forward < UTypes > ( elems ) ) ), ... );
    }
 
    template < std::size_t ... Indices >
    void des ( std::index_sequence < Indices ... > ) {
        ( delete std::get < Indices > ( m_data ), ... );
    }
 
public:
    ptr_tuple ( const ptr_tuple & tpl ) {
        copyCons ( std::make_index_sequence < sizeof ... ( Types ) > ( ), tpl );
    }
 
    ptr_tuple ( ptr_tuple && tpl ) {
        moveCons ( std::make_index_sequence < sizeof ... ( Types ) > ( ), std::move ( tpl ) );
    }
 
/*  template < class ... UTypes>
    ptr_tuple ( const ptr_tuple < UTypes ... > & tpl ) {
    }
 
    template < class ... UTypes >
    ptr_tuple ( ptr_tuple < UTypes ... > && tpl ) {
 
    }*/
 
    template < class ... UTypes >
    explicit ptr_tuple ( UTypes && ... elems ) {
        cons ( std::make_index_sequence < sizeof ... ( Types ) > ( ), std::forward < UTypes > ( elems ) ... );
    }
 
    ~ptr_tuple ( ) {
        des ( std::make_index_sequence < sizeof ... ( Types ) > ( ) );
    }
 
    ptr_tuple < Types ... > & operator = ( const ptr_tuple < Types ... > & other ) {
        if ( this == & other )
            return * this;
 
        des ( std::make_index_sequence < sizeof ... ( Types ) > ( ) );
        copyCons ( std::make_index_sequence < sizeof ... ( Types ) > ( ), other );
 
        return *this;
    }
 
    ptr_tuple < Types ... > & operator = ( ptr_tuple < Types ... > && other ) {
        std::swap ( m_data, other.m_data );
 
        return *this;
    }
 
    void swap ( ptr_tuple & 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 ) );
    }
 
    template < class R, std::size_t I >
    void set ( R && value ) {
        set < I > ( ext::clone ( std::forward < R > ( value ) ) );
    }
 
private:
    auto asTie ( ) const {
        auto accessor = [ & ] < std::size_t ... Is > ( std::index_sequence < Is ... > ) {
            return std::tie ( this->template get < Is > ( ) ... );
        };
        return accessor ( std::make_index_sequence < sizeof ... ( Types ) > ( ) );
    }
 
public:
    bool operator == ( const ext::ptr_tuple < Types ... > & second ) const {
        return this->asTie ( ) == second.asTie ( );
    }
 
    auto operator <=> ( const ext::ptr_tuple < Types ... > & second ) const {
        return this->asTie ( ) <=> second.asTie ( );
    }
 
};
 
template< class... Ts>
ext::ostream& operator<<(ext::ostream& out, const ext::ptr_tuple<Ts...>& tuple) {
    out << "(";
 
    bool first = true;
    auto outCallback = [ & ] ( const auto & arg0 ) {
        if ( ! first ) {
            out << ", ";
        } else {
            first = false;
        }
        out << arg0;
    };
 
    ext::foreach ( tuple, outCallback ); // TODO use std::apply like in ext::tuple, should work since C++20
    out << ")";
    return out;
}
 
} /* namespace ext */
 
namespace std {
 
template < std::size_t I, class ... Types >
const auto & get ( ext::ptr_tuple < Types ... > & tpl ) {
    return tpl.template get < I > ( );
}
 
template < std::size_t I, class ... Types >
const auto & get ( const ext::ptr_tuple < Types ... > & tpl ) {
    return tpl.template get < I > ( );
}
 
template < std::size_t I, class ... Types >
auto && get ( ext::ptr_tuple < Types ... > && tpl ) {
    return tpl.template get < I > ( );
}
 
} /* namespace std */
 
namespace ext {
 
template < typename... Elements >
constexpr auto make_ptr_tuple ( Elements && ... args ) {
    return ptr_tuple < typename ext::strip_reference_wrapper < std::decay_t < Elements > >::type ... > ( std::forward < Elements > ( args ) ... );
}
 
} /* namespace ext */
 
namespace std {
 
template < class ... Types >
struct tuple_size < ext::ptr_tuple < Types ... > > : public std::integral_constant < std::size_t, sizeof...( Types ) > { };
 
template < std::size_t I, class... Types >
struct tuple_element < I, ext::ptr_tuple < Types... > > {
    typedef typename std::tuple_element < I, std::tuple < Types ... > >::type type;
};
 
} /* namespace std */