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 <ext/ostream>
 
#include <extensions/common/tuple_common.hpp>
#include <extensions/container/pair.hpp>
 
namespace ext {
 
template < typename ... Ts >
class tuple : public std::tuple < Ts ... > {
public:
    using std::tuple< Ts ... >::tuple; // NOLINT(modernize-use-equals-default)
 
    using std::tuple< Ts ... >::operator =;
#ifndef __clang__
 
    tuple ( ) = default;
 
    tuple ( const tuple & other ) = default;
 
    tuple ( tuple && other ) = default;
 
    tuple & operator = ( tuple && other ) = default;
 
    tuple & operator = ( const tuple & other ) = default;
#endif
 
#ifdef _LIBCPP_VERSION // FIXME remove when libc++ gets standard conforming implementation of tuple's operator = (see: https://reviews.llvm.org/D50106)
    template < typename T, typename R >
    void assignSingle ( T & t, R & r ) {
        t = r;
    }
 
    template < typename ... Rs, size_t ... Indexes >
    void assign ( const tuple < Rs ... > & other, std::index_sequence < Indexes ... > ) {
        static_assert ( sizeof ... ( Ts ) == sizeof ... ( Rs ) );
        ( assignSingle ( std::get < Indexes > ( * this ), std::get < Indexes > ( other ) ), ... );
    }
 
    template < typename ... Rs >
    tuple & operator = ( const tuple < Rs ... > & other ) {
        assign ( other, std::make_index_sequence < sizeof ... ( Rs ) > ( ) );
        return * this;
    }
 
    template < typename T1, typename R2 >
    tuple & operator = ( const pair < T1, R2 > & other ) {
        static_assert ( 2 == sizeof ... ( Ts ) );
        std::get < 0 > ( * this ) = other.first;
        std::get < 1 > ( * this ) = other.second;
        return * this;
    }
#endif
 
    template < std::size_t I >
    auto & get ( ) & {
        return std::get < I > ( * this );
    }
 
    template < std::size_t I >
    auto && get ( ) && {
        return std::get < I > ( std::move ( * this ) );
    }
 
    template < std::size_t I >
    const auto & get ( ) const & {
        return std::get < I > ( * this );
    }
 
    template < class T, class R >
    requires ( sizeof ... ( Ts ) == 2 )
    operator ext::pair < T, R > ( ) const {
        return ext::pair < T, R > ( std::get < 0 > ( * this ), std::get < 1 > ( * this ) );
    }
 
    template < class T2, class R2 >
    constexpr auto operator <=> ( const ext::pair < T2, R2 > & second ) const;
 
};
 
template< class... Ts>
ext::ostream& operator<<(ext::ostream& out, const ext::tuple<Ts...>& tuple) {
    out << "(";
 
    if constexpr ( sizeof ... ( Ts ) > 0 ) {
        auto outCallback = [ & ] ( const auto & first, const auto & ... other ) {
            out << first;
            ( ( out << ", " << other ), ... );
        };
 
        std::apply ( outCallback, tuple );
    }
 
    out << ")";
    return out;
}
 
template < typename ... Elements >
constexpr auto make_tuple ( Elements && ... args ) {
    return tuple < typename ext::strip_reference_wrapper < std::decay_t < Elements > >::type ... > ( std::forward < Elements > ( args ) ... );
}
 
template<typename ... Elements >
constexpr tuple < Elements & ... > tie ( Elements & ... args ) noexcept {
    return tuple < Elements & ... > ( args ... );
}
 
template < typename ... Ts >
template < class T2, class R2 >
constexpr auto tuple < Ts ... >::operator <=> ( const ext::pair < T2, R2 > & second ) const {
    return (* this) <=> ext::tie ( second.first, second.second );
}
 
} /* namespace ext */
 
namespace std {
 
template < class ... Types >
struct tuple_size < ext::tuple < Types ... > > : public std::integral_constant < std::size_t, sizeof...( Types ) > { };
 
template < std::size_t I, class... Types >
struct tuple_element < I, ext::tuple < Types... > > {
    typedef typename std::tuple_element < I, std::tuple < Types ... > >::type type;
};
 
} /* namespace std */