unpack.hpp

/****************************************************************************
 *  hipipe library
 *  Copyright (c) 2017, Cognexa Solutions s.r.o.
 *  Copyright (c) 2018, Iterait a.s.
 *  Author(s) Filip Matzner
 *
 *  This file is distributed under the MIT License.
 *  See the accompanying file LICENSE.txt for the complete license agreement.
 ****************************************************************************/
 
#pragma once
 
#include <hipipe/core/stream/stream_t.hpp>
#include <hipipe/core/stream/template_arguments.hpp>
#include <hipipe/core/utility/ndim.hpp>
#include <hipipe/core/utility/tuple.hpp>
 
#include <range/v3/view/move.hpp>
#include <range/v3/view/transform.hpp>
 
namespace hipipe::stream {
 
namespace rgv = ranges::views;
 
namespace detail {
 
 
    template<std::size_t Dim, bool OnlyOne, typename... FromColumns>
    struct unpack_impl
    {
        template<typename Rng>
        static auto unpack_columns(Rng&& rng)
        {
            return rgv::transform(std::forward<Rng>(rng), [](batch_t source)
                -> std::tuple<typename FromColumns::data_type...> {
                    return {std::move(source.extract<FromColumns>())...};
            });
        }
 
        template<typename Rng>
        static
        std::tuple<std::vector<utility::ndim_type_t<typename FromColumns::data_type, Dim>>...>
        impl(Rng&& range_of_batches)
        {
            static_assert(std::is_same_v<std::decay_t<ranges::range_value_t<Rng>>, batch_t>,
              "hipipe::stream::unpack requires a range of batches as input.");
            static_assert(((Dim <= utility::ndims<typename FromColumns::data_type>::value) && ...),
              "hipipe::stream::unpack requires the requested dimension to be less or equal to the"
              " dimension of all the unpacked columns.");
            auto raw_range_of_tuples = unpack_columns(std::forward<Rng>(range_of_batches));
            auto tuple_of_batches = utility::unzip(std::move(raw_range_of_tuples));
            // flatten the values in each column upto the given dimension
            return utility::tuple_transform(std::move(tuple_of_batches), [](auto&& batch_range) {
                // make sure to convert the flat view to std::vector to avoid dangling ref
                return rgv::move(utility::flat_view<Dim+1>(batch_range));
            });
        }
    };
 
    // if only a single column is unpacked, do not return a tuple
    template<std::size_t Dim, typename FromColumn>
    struct unpack_impl<Dim, true, FromColumn>
    {
        template<typename Rng>
        static
        std::vector<utility::ndim_type_t<typename FromColumn::data_type, Dim>>
        impl(Rng&& range_of_tuples)
        {
            return std::get<0>(
              unpack_impl<Dim, false, FromColumn>::impl(std::forward<Rng>(range_of_tuples)));
        }
    };
 
}  // namespace detail
 
 
template<typename Rng, typename... FromColumns, int Dim = 1>
auto
// The return type is actually the following, but GCC won't handle it.
// utility::maybe_tuple<std::vector<utility::ndim_type_t<typename FromColumns::data_type, Dim>>...>
unpack(Rng&& rng, from_t<FromColumns...> f, dim_t<Dim> d = dim_t<1>{})
{
    return detail::unpack_impl<Dim, (sizeof...(FromColumns)==1), FromColumns...>::impl(
      std::forward<Rng>(rng));
}
 
}  // end namespace hipipe::stream