从嵌套包中提取每个"叶包"

Extract every "leaf-pack" from a pack of nested packs

本文关键字：叶包 提取 嵌套 包中      更新时间：2023-10-16

ExtractEveryPack<Pack>::type是Pack中所有"叶包"中的包。例如，ExtractEveryPack< Pack<double, Pack<int, char>, int, Pack<long, short>> >::type就是Pack< Pack<int, char>, Pack<long, short> >。但"外包装"不会退回。只有最内层的包装（我称之为"叶子包装"）被提取出来。所以

ExtractEveryPack<Pack<Pack<int, double>, char, Pack<long, Pack<Pack<int, char>, Pack<char, Pack<double, int>>>, char>, int, Pack<short, int>>>::type,

是

Pack< Pack<int, double>, Pack<int, char>, Pack<double, int>, Pack<short, int>.

我的想法是：默认情况下，ExtractEveryPack<T>::type是T。然后递归地，将ExtractEveryPack应用于每个类型，并删除所有不是包的类型：

#include <iostream>
template <typename, typename> struct RemoveNonPacksHelper;
template <template <typename...> class P, typename... Accumulated>
struct RemoveNonPacksHelper<P<>, P<Accumulated...>> {
    using type = P<Accumulated...>;
};
template <template <typename...> class P, typename First, typename... Rest, typename... Accumulated>
struct RemoveNonPacksHelper<P<First, Rest...>, P<Accumulated...>> : RemoveNonPacksHelper<P<Rest...>, P<Accumulated...>> {};
template <template <typename...> class P, typename... Types, typename... Rest, typename... Accumulated>
struct RemoveNonPacksHelper<P<P<Types...>, Rest...>, P<Accumulated...>> : RemoveNonPacksHelper<P<Rest...>, P<Accumulated..., P<Types...>>> {};
template <typename> struct RemoveNonPacks;
template <template <typename...> class P, typename... Types>
struct RemoveNonPacks<P<Types...>> : RemoveNonPacksHelper<P<Types...>, P<>> {};
template <typename T> struct Identity { using type = T; };
template <typename T>
struct ExtractEveryPack : Identity<T> {};  // Do nothing for non-packs.
// The key idea here, but apparently not correct:
template <template <typename...> class P, typename... Types>
struct ExtractEveryPack<P<Types...>> :
    RemoveNonPacks<P<typename ExtractEveryPack<Types>::type...>> {};
// Testing
template <typename...> struct Pack {};
int main() {
    std::cout << std::boolalpha << std::is_same< 
        RemoveNonPacks< Pack<Pack<int, double>, char, Pack<long, double, char>, int, Pack<short, int>> >::type,
        Pack<Pack<int, double>, Pack<long, double, char>, Pack<short, int>>
    >::value << std::endl;  // true
    std::cout << std::is_same<
        ExtractEveryPack<Pack<Pack<int, double>, char, Pack<long, Pack<Pack<int, char>, Pack<char, Pack<double, int>>>, char>, int, Pack<short, int>>>::type,
        Pack< Pack<int, double>, Pack<int, char>, Pack<double, int>, Pack<short, int> >
    >::value << std::endl;  // false (darn!)
}

这里怎么了？我的计划还是它的实施？什么是更好的计划？

值得一提的是，这里有一个帮助结构IsLeafPack来确定一个包是否由其他包组成（测试），尽管我还没有想到如何使用它：

template <typename> struct IsLeafPack;
template <template <typename...> class P>
struct IsLeafPack<P<>> : std::true_type {};
template <template <typename...> class P, template <typename...> class P2, typename... Types, typename... Rest>
struct IsLeafPack<P<P2<Types...>, Rest...>> : std::false_type {};
template <template <typename...> class P, typename First, typename... Rest>
struct IsLeafPack<P<First, Rest...>> : IsLeafPack<P<Rest...>> {};

递归是正确的。但是应用ExtractEveryPack的结果可以是任意数量（包括0）的叶包。因此，它必须返回一组类型，而不是返回单个类型。然后可以将这些包连接起来以产生最终输出。

// A pack template.
template <typename...> struct Pack {};
// Test if Ts... contains any pack - not necessarily a Pack.
template <typename... Ts> 
struct contains_any_pack : std::false_type {};
template <template <typename...> class P, typename... TPs, typename... Ts> 
struct contains_any_pack<P<TPs...>, Ts...> : std::true_type {};
template <class F, typename... Ts> 
struct contains_any_pack<F, Ts...> : contains_any_pack<Ts...> {};
// concatenates a list of Pack's into one Pack.
template <typename... Ts> struct concat_packs;
template <typename... Ts>
struct concat_packs<Pack<Ts...>> { using type = Pack<Ts...>; };
template <typename... Ts, typename... T1s, typename... T2s>
struct concat_packs<Pack<Ts...>, Pack<T1s...>, T2s... > 
     : concat_packs<Pack<Ts..., T1s...>, T2s... > {};

// T isn't a pack - return an empty Pack
template <typename T>
struct ExtractEveryPack { using type = Pack<>; };  
// if P<Ts...> is a leaf pack, return it wrapped in a Pack.
// else, apply ExtractEveryPack to Ts... recursively,
// and concatenate the results
template <template <typename...> class P, typename... Ts>
struct ExtractEveryPack<P<Ts...>> { 
    using type = typename std::conditional<contains_any_pack<Ts...>::value,
                                  typename concat_packs<typename ExtractEveryPack<Ts>::type...>::type,
                                  Pack<P<Ts...>>>::type; 
};

为了简化实现，上面的ExtractEveryPack总是返回叶包的Pack。然而，叶包的类型不限于Pack s。

相关文章：