feedc0de/boost_mp11
1
0
Fork 0
forked from boostorg/mp11
Code Pull Requests Activity

Add mp_copy_if, mp_remove_if, mp_partition, mp_sort.

Browse Source
This commit is contained in:
Peter Dimov
2015-06-24 16:05:47 +03:00
parent 05ab3e7a42
commit baaead6860
6 changed files with 352 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

147
include/boost/mp11/algorithm.hpp
View File

@@ -354,17 +354,156 @@ template<class L, template<class...> class P, class W> struct mp_replace_if_impl
template<class L, template<class...> class P, class W> using mp_replace_if = typename detail::mp_replace_if_impl<L, P, W>::type; template<class L, template<class...> class P, class W> using mp_replace_if = typename detail::mp_replace_if_impl<L, P, W>::type;
// mp_copy_if<L, P>
namespace detail
{
template<class L, template<class...> class P> struct mp_copy_if_impl;
#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1800 )
template<template<class...> class L, class... T, template<class...> class P> struct mp_copy_if_impl<L<T...>, P>
{
static_assert( sizeof...(T) == 0, "T... must be empty" );
using type = L<>;
};
#else
template<template<class...> class L, template<class...> class P> struct mp_copy_if_impl<L<>, P>
{
using type = L<>;
};
#endif
template<template<class...> class L, class T1, class... T, template<class...> class P> struct mp_copy_if_impl<L<T1, T...>, P>
{
using rest = typename mp_copy_if_impl<L<T...>, P>::type;
using type = mp_if<P<T1>, mp_push_front<rest, T1>, rest>;
};
} // namespace detail
template<class L, template<class...> class P> using mp_copy_if = typename detail::mp_copy_if_impl<L, P>::type;
// mp_remove_if<L, P>
namespace detail
{
template<class L, template<class...> class P> struct mp_remove_if_impl;
#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1800 )
template<template<class...> class L, class... T, template<class...> class P> struct mp_remove_if_impl<L<T...>, P>
{
static_assert( sizeof...(T) == 0, "T... must be empty" );
using type = L<>;
};
#else
template<template<class...> class L, template<class...> class P> struct mp_remove_if_impl<L<>, P>
{
using type = L<>;
};
#endif
template<template<class...> class L, class T1, class... T, template<class...> class P> struct mp_remove_if_impl<L<T1, T...>, P>
{
using rest = typename mp_remove_if_impl<L<T...>, P>::type;
using type = mp_if<P<T1>, rest, mp_push_front<rest, T1>>;
};
} // namespace detail
template<class L, template<class...> class P> using mp_remove_if = typename detail::mp_remove_if_impl<L, P>::type;
// mp_partition<L, P>
namespace detail
{
template<class L, template<class...> class P> struct mp_partition_impl;
#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1800 )
template<template<class...> class L, class... T, template<class...> class P> struct mp_partition_impl<L<T...>, P>
{
static_assert( sizeof...(T) == 0, "T... must be empty" );
using type = L<L<>, L<>>;
};
#else
template<template<class...> class L, template<class...> class P> struct mp_partition_impl<L<>, P>
{
using type = L<L<>, L<>>;
};
#endif
template<template<class...> class L, class T1, class... T, template<class...> class P> struct mp_partition_impl<L<T1, T...>, P>
{
using rest = typename mp_partition_impl<L<T...>, P>::type;
using type = mp_if<P<T1>, L<mp_push_front<mp_first<rest>, T1>, mp_second<rest>>, L<mp_first<rest>, mp_push_front<mp_second<rest>, T1>>>;
};
} // namespace detail
template<class L, template<class...> class P> using mp_partition = typename detail::mp_partition_impl<L, P>::type;
// mp_sort<L, P>
namespace detail
{
template<class L, template<class...> class P> struct mp_sort_impl;
#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1800 )
template<template<class...> class L, class... T, template<class...> class P> struct mp_sort_impl<L<T...>, P>
{
static_assert( sizeof...(T) == 0, "T... must be empty" );
using type = L<>;
};
#else
template<template<class...> class L, template<class...> class P> struct mp_sort_impl<L<>, P>
{
using type = L<>;
};
#endif
template<template<class...> class L, class T1, template<class...> class P> struct mp_sort_impl<L<T1>, P>
{
using type = L<T1>;
};
template<template<class...> class L, class T1, class... T, template<class...> class P> struct mp_sort_impl<L<T1, T...>, P>
{
template<class U> using F = P<U, T1>;
using part = mp_partition<L<T...>, F>;
using S1 = typename mp_sort_impl<mp_first<part>, P>::type;
using S2 = typename mp_sort_impl<mp_second<part>, P>::type;
using type = mp_append<mp_push_back<S1, T1>, S2>;
};
} // namespace detail
template<class L, template<class...> class P> using mp_sort = typename detail::mp_sort_impl<L, P>::type;
// mp_find<L, V> // mp_find<L, V>
// mp_find_if<L, P> // mp_find_if<L, P>
// mp_find_index<L, V> // mp_find_index<L, V>
// mp_find_index_if<L, P> // mp_find_index_if<L, P>
// mp_reverse<L> // mp_reverse<L>
// mp_copy_if<L, P>
// mp_remove_if<L, P>
// mp_fold<L, V, F> // mp_fold<L, V, F>
// mp_reverse_fold<L, V, F> // mp_reverse_fold<L, V, F>
// mp_partition<L, P>
// mp_sort<L>
} // namespace boost } // namespace boost

4
test/Jamfile.v2
View File

@@ -40,6 +40,10 @@ run mp_at.cpp : : : $(REQ) ;
run mp_take.cpp : : : $(REQ) ; run mp_take.cpp : : : $(REQ) ;
run mp_replace.cpp : : : $(REQ) ; run mp_replace.cpp : : : $(REQ) ;
run mp_replace_if.cpp : : : $(REQ) ; run mp_replace_if.cpp : : : $(REQ) ;
run mp_copy_if.cpp : : : $(REQ) ;
run mp_remove_if.cpp : : : $(REQ) ;
run mp_partition.cpp : : : $(REQ) ;
run mp_sort.cpp : : : $(REQ) ;
# integral # integral
run integral.cpp : : : $(REQ) ; run integral.cpp : : : $(REQ) ;

50
test/mp_copy_if.cpp Normal file
View File

@@ -0,0 +1,50 @@
// Copyright 2015 Peter Dimov.
//
// Distributed under the Boost Software License, Version 1.0.
//
// See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
#include <boost/mp11/algorithm.hpp>
#include <boost/mp11/list.hpp>
#include <boost/core/lightweight_test_trait.hpp>
#include <type_traits>
#include <tuple>
struct X1 {};
struct X2 {};
struct X3 {};
int main()
{
using boost::mp_list;
using boost::mp_copy_if;
{
using L1 = mp_list<>;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if<L1, std::is_const>, L1>));
using L2 = mp_list<X1, X1 const, X1*, X2 const, X2*, X3*>;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if<L2, std::is_volatile>, L1>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if<L2, std::is_const>, mp_list<X1 const, X2 const>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if<L2, std::is_pointer>, mp_list<X1*, X2*, X3*>>));
}
{
using L1 = std::tuple<>;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if<L1, std::is_const>, L1>));
using L2 = std::tuple<X1, X1 const, X1*, X2 const, X2*, X3*>;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if<L2, std::is_volatile>, L1>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if<L2, std::is_const>, std::tuple<X1 const, X2 const>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if<L2, std::is_pointer>, std::tuple<X1*, X2*, X3*>>));
}
return boost::report_errors();
}

50
test/mp_partition.cpp Normal file
View File

@@ -0,0 +1,50 @@
// Copyright 2015 Peter Dimov.
//
// Distributed under the Boost Software License, Version 1.0.
//
// See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
#include <boost/mp11/algorithm.hpp>
#include <boost/mp11/list.hpp>
#include <boost/core/lightweight_test_trait.hpp>
#include <type_traits>
#include <tuple>
struct X1 {};
struct X2 {};
struct X3 {};
int main()
{
using boost::mp_list;
using boost::mp_partition;
{
using L1 = mp_list<>;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition<L1, std::is_const>, mp_list<L1, L1>>));
using L2 = mp_list<X1, X1 const, X1*, X2 const, X2*, X3*>;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition<L2, std::is_volatile>, mp_list<L1, L2>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition<L2, std::is_const>, mp_list<mp_list<X1 const, X2 const>, mp_list<X1, X1*, X2*, X3*>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition<L2, std::is_pointer>, mp_list<mp_list<X1*, X2*, X3*>, mp_list<X1, X1 const, X2 const>>>));
}
{
using L1 = std::tuple<>;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition<L1, std::is_const>, std::tuple<L1, L1>>));
using L2 = std::tuple<X1, X1 const, X1*, X2 const, X2*, X3*>;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition<L2, std::is_volatile>, std::tuple<L1, L2>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition<L2, std::is_const>, std::tuple<std::tuple<X1 const, X2 const>, std::tuple<X1, X1*, X2*, X3*>>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition<L2, std::is_pointer>, std::tuple<std::tuple<X1*, X2*, X3*>, std::tuple<X1, X1 const, X2 const>>>));
}
return boost::report_errors();
}

50
test/mp_remove_if.cpp Normal file
View File

@@ -0,0 +1,50 @@
// Copyright 2015 Peter Dimov.
//
// Distributed under the Boost Software License, Version 1.0.
//
// See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
#include <boost/mp11/algorithm.hpp>
#include <boost/mp11/list.hpp>
#include <boost/core/lightweight_test_trait.hpp>
#include <type_traits>
#include <tuple>
struct X1 {};
struct X2 {};
struct X3 {};
int main()
{
using boost::mp_list;
using boost::mp_remove_if;
{
using L1 = mp_list<>;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if<L1, std::is_const>, L1>));
using L2 = mp_list<X1, X1 const, X1*, X2 const, X2*, X3*>;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if<L2, std::is_volatile>, L2>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if<L2, std::is_const>, mp_list<X1, X1*, X2*, X3*>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if<L2, std::is_pointer>, mp_list<X1, X1 const, X2 const>>));
}
{
using L1 = std::tuple<>;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if<L1, std::is_const>, L1>));
using L2 = std::tuple<X1, X1 const, X1*, X2 const, X2*, X3*>;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if<L2, std::is_volatile>, L2>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if<L2, std::is_const>, std::tuple<X1, X1*, X2*, X3*>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if<L2, std::is_pointer>, std::tuple<X1, X1 const, X2 const>>));
}
return boost::report_errors();
}

55
test/mp_sort.cpp Normal file
View File

@@ -0,0 +1,55 @@
// Copyright 2015 Peter Dimov.
//
// Distributed under the Boost Software License, Version 1.0.
//
// See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
#include <boost/mp11/algorithm.hpp>
#include <boost/mp11/list.hpp>
#include <boost/mp11/integral.hpp>
#include <boost/core/lightweight_test_trait.hpp>
#include <type_traits>
#include <tuple>
using boost::mp_bool;
template<class T, class U> using sizeof_less = mp_bool<(sizeof(T) < sizeof(U))>;
int main()
{
using boost::mp_list;
using boost::mp_sort;
{
using L1 = mp_list<>;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sort<L1, sizeof_less>, L1>));
using L2 = mp_list<char[2], char[4], char[3], char[1]>;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sort<L2, sizeof_less>, mp_list<char[1], char[2], char[3], char[4]>>));
using L3 = mp_list<char[2], char[4], char[2], char[3], char[1], char[2], char[1]>;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sort<L3, sizeof_less>, mp_list<char[1], char[1], char[2], char[2], char[2], char[3], char[4]>>));
}
{
using L1 = std::tuple<>;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sort<L1, sizeof_less>, L1>));
using L2 = std::tuple<char[2], char[4], char[3], char[1]>;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sort<L2, sizeof_less>, std::tuple<char[1], char[2], char[3], char[4]>>));
using L3 = std::tuple<char[2], char[4], char[2], char[3], char[1], char[2], char[1]>;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sort<L3, sizeof_less>, std::tuple<char[1], char[1], char[2], char[2], char[2], char[3], char[4]>>));
}
return boost::report_errors();
}