brick-tuple

// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 4 -*-

/*
 * This header provides functionality of unpacking tuples into function
 * arguments.
 *
 * It define 3 main functions:
 * pass( fn, tuple ) takes callable object and tuple and unpacks tuple
 * into arguments of fn
 *
 * pass( x, method, tuple ) which acts like previous version, except it
 * calls method pointer method on x (which can be either pointer or object
 * directly)
 *
 * passIx< ixs... >( ... ) which acts exactly like (one of) pass functions
 * above but forwards only values on specified indices (in order)
 *
 *
 * In all cases exact prototype of function which can be called depends on
 * type of tuple:
 * - if tuple is value or rvalue reference, none of the arguments in function
 *   shall be non-const lvalue references (that is, tuple constents are
 *   forwarded as rvalues)
 * - if tuple is lvalue reference, none of the arguments in function shall
 *   be rvalue references (that is, tuple contends are forwarded as lvalue)
 * - const qualification of tuple is preserved
 *
 * Furthermore, following functions and types are provided and not considered
 * implementation details:
 * template< int... > struct Indices; for holding indices of tuple
 *
 * template< typename Tuple > GetIndices; for obtaining indices of tuple
 * - defines single nested name Ix of form Indices< ix... > for some ix
 *   which represents indices of tuple (if Tuple is in form std::tuple< ... >)
 * - otherwise is empty type with no nested names
 *
 * bindThis( x, method )  produces callable object which calls x.*m( ... )
 */

/*
 * (c) 2014 Vladimír Štill <xstill@fi.muni.cz>
 */

/* Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE. */

#pragma once

#include <tuple>
#include <iostream>
#include <array>
#include <numeric>
#include <functional>
#include <type_traits>

#include <brick-assert>

namespace brick::tuple
{

template< int... Ixs >
struct Indices {
    static constexpr int size = sizeof...( Ixs );
};

template< int... > struct _Expand { };

template< int... is >
struct _Expand< 0, is... > {
    using Ix = Indices< 0, is... >;
};

template< int i, int... is >
struct _Expand< i, is... > {
    static_assert( i > 0, "invalid param in _Expand" );

    using Ix = typename _Expand< i - 1, i, is... >::Ix;
};

template< typename... > struct _GetIndices { };

template< typename T, typename... Ts >
struct _GetIndices< T, Ts... > {
    using Ix = typename _Expand< sizeof...( Ts ) >::Ix;
};

template<>
struct _GetIndices<> {
    using Ix = Indices<>;
};

template< typename > struct GetIndices;

template< typename... Args >
struct GetIndices< std::tuple< Args... > > : _GetIndices< Args... > { };

template< typename > struct _Pass { };

template< int... ix >
struct _Pass< Indices< ix... > > {

    template< typename Fn, typename Tuple >
#ifdef BRICK_TUPLE_INLINE_PASS
    __attribute__(( __always_inline__, __flatten__))
#endif
    static auto call( Fn &&fn, typename std::remove_reference< Tuple >::type &tuple )
        -> decltype( fn( std::get< ix >( tuple )... ) )
    {
        return fn( std::get< ix >( tuple )... );
    }

    template< size_t i, typename Tuple >
#ifdef BRICK_TUPLE_INLINE_PASS
    __attribute__(( __always_inline__, __flatten__))
#endif
    static auto getrvalue( Tuple &tuple )
        -> typename std::tuple_element< i, Tuple >::type &&
    {
        return static_cast< typename std::tuple_element< i, Tuple >::type && >(
                std::get< i >( tuple ) );
    }

    template< typename Fn, typename Tuple >
#ifdef BRICK_TUPLE_INLINE_PASS
    __attribute__(( __always_inline__, __flatten__))
#endif
    static auto call( Fn &&fn, typename std::remove_reference< Tuple >::type &&tuple )
        -> decltype( fn( getrvalue< ix >( tuple )... ) )
    {
        return fn( getrvalue< ix >( tuple )... );
    }
};

template< typename T, typename Method >
class BindThis {
    T _self;
    Method _m;
  public:

    BindThis( T &&self, Method &&m ) :
        _self( std::forward< T >( self ) ),
        _m( std::forward< Method >( m ) )
    { }

    template< typename... Args >
    auto operator()( Args &&... args )
        -> decltype( (std::declval< T >().*std::declval< Method >())( std::forward< Args >( args )... ) )
    {
        return (_self.*_m)( std::forward< Args >( args )... );
    }
};

template< typename T, typename Method >
auto bindThis( T &&self, Method &&method )
    -> typename std::enable_if< std::is_member_function_pointer< Method >::value,
                                BindThis< T, Method > >::type
{
    return BindThis< T, Method >(
            std::forward< T >( self ), std::forward< Method >( method ) );
}

template< typename T, typename Method >
auto bindThis( T *self, Method &&method )
    -> typename std::enable_if< std::is_member_function_pointer< Method >::value,
                                BindThis< T &, Method > >::type
{
    return BindThis< T &, Method >( *self, std::forward< Method >( method ) );
}

template< typename Fn, typename Tuple,
    typename Ix = typename GetIndices< typename std::decay< Tuple >::type >::Ix >
auto pass( Fn &&fn, Tuple &&tuple )
    -> decltype( _Pass< Ix >::template call< Fn, Tuple >(
                std::forward< Fn >( fn ), std::forward< Tuple >( tuple ) ) )
{
    return _Pass< Ix >::template call< Fn, Tuple >(
            std::forward< Fn >( fn ), std::forward< Tuple >( tuple ) );
}

template< typename T, typename Fn, typename Tuple,
    typename UIx = typename GetIndices< typename std::decay< Tuple >::type >::Ix >
auto pass( T &&obj, Fn &&method, Tuple &&tuple )
    -> decltype( pass( bindThis( std::forward< T >( obj ),
                                 std::forward< Fn >( method ) ),
                       std::forward< Tuple >( tuple ) ) )
{
    return pass( bindThis( std::forward< T >( obj ), std::forward< Fn >( method ) ),
                 std::forward< Tuple >( tuple ) );
}

template< int... ix, typename... Args >
auto passIx( Args &&...args )
    -> decltype( pass< Args..., Indices< ix... > >( std::forward< Args >( args )... ) )
{
    return pass< Args..., Indices< ix... > >( std::forward< Args >( args )... );
}

template< int i, typename T >
void print( std::ostream &o, const T &t )
{
    if constexpr ( i < std::tuple_size_v< T > )
    {
        o << std::get< i >( t ) << ( ( i < std::tuple_size_v< T > - 1 ) ? " " : "" );
        print< i + 1 >( o, t );
    }
}

template< typename... Args >
std::ostream &operator<<( std::ostream &o, const std::tuple< Args... > &t )
{
    o << "[";
    print< 0 >( o, t );
    return o << "]";
}

template< size_t... Is >
auto index_tuple( std::index_sequence< Is... > ) {
    return std::tuple( std::integral_constant< size_t, Is >()... );
}

template< typename > struct Witness { };

template< typename... Ts >
auto index_tuple( Witness< std::tuple< Ts... > > ) {
    return index_tuple( std::index_sequence_for< Ts... >() );
}

template< typename T >
auto index_tuple() {
    return index_tuple( Witness< std::decay_t< T > >() );
}

// apply a function to each element of a tuple, returning a tuple of resutls
template< typename F, typename Tup >
auto pointwise_apply( F &&f, Tup &&tup ) {
    return std::apply( [&]( auto... idxs ) {
            return std::tuple( f( std::get< idxs.value >( tup ) )... );
        }, index_tuple< Tup >() );
}

// zip-apply a function on a pair of (same length) tuples, and then reduce the
// results the return type for all pairs has to be convertible to E and will be
// converted to E before reduction
template< typename F, typename R, typename E, typename Tup1, typename Tup2,
          typename = std::enable_if_t< std::tuple_size< std::decay_t< Tup1 > >::value
                                       == std::tuple_size< std::decay_t< Tup2 > >::value > >
auto pointwise_zip_reduce( F &&f, R &&r, E &&e, Tup1 &&t1, Tup2 &&t2 ) {
    constexpr size_t sz = std::tuple_size< std::decay_t< Tup1 > >::value;

    auto results = std::apply( [&]( auto... idxs ) {
            return std::array< E, sz >{
                { E( f( std::get< idxs.value >( t1 ), std::get< idxs.value >( t2 ) ) )... } };
        }, index_tuple< Tup1 >() );
    return std::accumulate( results.begin(), results.end(), e, r );
}

// zip-apply a function on a pair of (same length) tuples, produce nothing
// (function is encouraged to have side effect)
template< typename F, typename Tup1, typename Tup2,
          typename = std::enable_if_t< std::tuple_size< std::decay_t< Tup1 > >::value
                                       == std::tuple_size< std::decay_t< Tup2 > >::value > >
auto pointwise_zip_void( F &&f, Tup1 &&t1, Tup2 &&t2 ) {
    std::apply( [&]( auto... idxs ) {
            ( f( std::get< idxs.value >( t1 ), std::get< idxs.value >( t2 ) ),... );
        }, index_tuple< Tup1 >() );
}

}

#include <sstream>

namespace brick::t_tuple
{

using namespace tuple;

struct Obj {
    void m1( int x ) { ASSERT_EQ( x, 42 ); }
    int m2( int x, int y ) { return x + y; }
    int m3( int x ) { return x + z; }

    int z;
};

struct Tuple {
    TEST(call_empty) {
        std::tuple<> t;
        bool called = false;
        pass( [&] { called = true; }, t );
        ASSERT( called );
    }

    TEST(call_single) {
        std::tuple< int > t( 42 );
        bool called = false;
        pass( [&]( int x ) {
                called = true;
                ASSERT_EQ( x, 42 );
            }, t );
        ASSERT( called );
    }

    TEST(call_multi) {
        bool called = false;
        std::tuple< int, bool &, bool * > t( 42, called, &called );
        pass( [&]( int x, bool &cr, bool *cp ) {
                called = true;
                ASSERT( cr );
                ASSERT( *cp );
                ASSERT( &cr == cp );
                ASSERT( &called == cp );
                ASSERT_EQ( x, 42 );
            }, t );
        ASSERT( called );
    }

    TEST(call_lvalue) {
        std::tuple< int > t( 0 );
        pass( []( int &x ) { x = 42; }, t );
        ASSERT_EQ( std::get< 0 >( t ), 42 );
        pass( []( const int &x ) { ASSERT_EQ( x, 42 ); }, t );
        // pass( []( int &&x ) { }, t ); // this should not compile
    }

    TEST(call_rvalue) {
        pass( []{ }, std::tuple<>() );
        pass( []( int x ) { ASSERT_EQ( x, 42 ); }, std::tuple< int >( 42 ) );
        pass( []( int &&x ) { ASSERT_EQ( x, 42 ); }, std::tuple< int >( 42 ) );
        // pass( []( int &x ) { ASSERT_EQ( x, 42 ); }, std::tuple< int >( 42 ) ); // this should not compile

        int x = 0;
        pass( []( int &x ) { x = 42; }, std::tuple< int & >( x ) );
        ASSERT_EQ( x, 42 );

        std::tuple< int, int > t( 40, 2 );
        x = pass( []( int x, int &&y ) { return x + y; }, std::move( t ) );
        ASSERT_EQ( x, 42 );
    }

    TEST(retval) {
        auto l = []( int x ) { return x + 2; };
        ASSERT_EQ( pass( l, std::tuple< int >( 40 ) ), 42 );
        int z = pass( []( int x, int y ) { return x + y; }, std::tuple< int, int >( 40, 2 ) );
        ASSERT_EQ( z, 42 );
    }

    TEST(bind_this) {
        Obj o;
        o.z = 40;
        bindThis( o, &Obj::m1 )( 42 );
        ASSERT_EQ( bindThis( o, &Obj::m3 )( 2 ), 42 );
    }

    TEST(obj_bind) {
        Obj o;
        o.z = 40;
        pass( bindThis( o, &Obj::m1 ), std::tuple< int >( 42 ) );
        int r = pass( bindThis( o, &Obj::m2 ), std::tuple< int, int >( 40, 2 ) );
        ASSERT_EQ( r, 42 );
        r = pass( bindThis( o, &Obj::m3 ), std::tuple< int >( 2 ) );
        ASSERT_EQ( r, 42 );
        o.z = 2;
        r = pass( bindThis( o, &Obj::m3 ), std::tuple< int >( 40 ) );
        ASSERT_EQ( r, 42 );
    }

    TEST(obj) {
        Obj o;
        o.z = 40;
        pass( o, &Obj::m1, std::tuple< int >( 42 ) );
        int r = pass( o, &Obj::m2, std::tuple< int, int >( 40, 2 ) );
        ASSERT_EQ( r, 42 );
        r = pass( o, &Obj::m3, std::tuple< int >( 2 ) );
        ASSERT_EQ( r, 42 );
        o.z = 2;
        r = pass( o, &Obj::m3, std::tuple< int >( 40 ) );
        ASSERT_EQ( r, 42 );
    }

    TEST(objptr) {
        Obj o;
        o.z = 40;
        pass( &o, &Obj::m1, std::tuple< int >( 42 ) );
        int r = pass( &o, &Obj::m2, std::tuple< int, int >( 40, 2 ) );
        ASSERT_EQ( r, 42 );
        r = pass( &o, &Obj::m3, std::tuple< int >( 2 ) );
        ASSERT_EQ( r, 42 );
        o.z = 2;
        r = pass( &o, &Obj::m3, std::tuple< int >( 40 ) );
        ASSERT_EQ( r, 42 );
    }

    TEST(pass_ix) {
        std::tuple< int, long, bool, int, int > t( 42, 1024l * 1024l * 1024l * 1024l, true, 40, 2 );
        passIx< 0 >( []( int x ) { ASSERT_EQ( x, 42 ); }, t );
        passIx< 1 >( []( long x ) { ASSERT_EQ( x, 1024l * 1024l * 1024l * 1024l ); }, t );
        passIx< 2, 0 >( []( bool b, int x ) { ASSERT( b ); ASSERT_EQ( x, 42 ); }, t );
        int r = passIx< 3, 4 >( []( int x, int y ) { return x + y; }, t );
        ASSERT_EQ( r, 42 );
    }

    struct CheckConst {
        template< typename T >
        void operator()( T & ) {
            static_assert( std::is_const< T >::value, "const got lost" );
        }
    };

    TEST(call_const) {
        const std::tuple< int > t( 42 );
        pass( []( const int &x ) { ASSERT_EQ( x, 42 ); }, t );
        pass( []( int x ) { ASSERT_EQ( x, 42 ); }, t );
        pass( CheckConst(), t );

        std::tuple< const int > tc( 42 );
        pass( CheckConst(), tc );

        int x = 42;
        pass( CheckConst(), std::tuple< const int & >( x ) );
    }

    TEST(pw_apply) {
        std::tuple< int, long, unsigned > t{ 42, 3, 0 };
        auto ta = pointwise_apply( []( auto v ) { return v + 1; }, t );
        static_assert( std::is_same< decltype( t ), decltype( ta ) >::value );
        ASSERT_EQ( std::get< 0 >( ta ), 43 );
        ASSERT_EQ( std::get< 1 >( ta ), 4 );
        ASSERT_EQ( std::get< 2 >( ta ), 1 );
    }

    TEST(pw_zip_void) {
        std::tuple< int, long > t1{ 42, 1 };
        std::tuple< long, int > t2{ 8, 41 };
        long res[2];
        int i = 0;

        pointwise_zip_void( [&]( auto a, auto b ) { res[ i++ ] = a + b; }, t1, t2 );
        ASSERT_EQ( i, 2 );
        ASSERT_EQ( res[ 0 ], 50 );
        ASSERT_EQ( res[ 1 ], 42 );
    }

    TEST(pw_zip_reduce) {
        std::tuple< int, int > t1 { 1, 2 };
        std::tuple< long, long > t2 { 3, 4 };

        auto v = pointwise_zip_reduce( std::plus< void >(), std::multiplies< void >(), 1, t1, t2 );
        static_assert( std::is_same< int, decltype( v ) >::value,
                       "result of pointwise_zip_reduce does not have type of the base case" );
        ASSERT_EQ( v, (1 + 3) * (2 + 4) );
    }
};

struct Print
{
    TEST(print_0)
    {
        std::tuple<> t;
        std::stringstream s;
        s << t;
        ASSERT_EQ( s.str(), "[]" );
    }

    TEST(print_1)
    {
        std::tuple< int > t( 1 );
        std::stringstream s;
        s << t;
        ASSERT_EQ( s.str(), "[1]" );
    }

    TEST(print_2)
    {
        std::tuple< int, char > t( 1, 'c' );
        std::stringstream s;
        s << t;
        ASSERT_EQ( s.str(), "[1 c]" );
    }
};

}

// vim: syntax=cpp tabstop=4 shiftwidth=4 expandtab ft=cpp