boost/accumulators/framework/depends_on.hpp
/////////////////////////////////////////////////////////////////////////////// // depends_on.hpp // // Copyright 2005 Eric Niebler. 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) #ifndef BOOST_ACCUMULATORS_FRAMEWORK_DEPENDS_ON_HPP_EAN_28_10_2005 #define BOOST_ACCUMULATORS_FRAMEWORK_DEPENDS_ON_HPP_EAN_28_10_2005 #include <boost/version.hpp> #include <boost/mpl/end.hpp> #include <boost/mpl/map.hpp> #include <boost/mpl/fold.hpp> #include <boost/mpl/size.hpp> #include <boost/mpl/sort.hpp> #include <boost/mpl/insert.hpp> #include <boost/mpl/assert.hpp> #include <boost/mpl/remove.hpp> #include <boost/mpl/vector.hpp> #include <boost/mpl/inherit.hpp> #include <boost/mpl/identity.hpp> #include <boost/mpl/equal_to.hpp> #include <boost/mpl/contains.hpp> #include <boost/mpl/transform.hpp> #include <boost/mpl/is_sequence.hpp> #include <boost/mpl/placeholders.hpp> #include <boost/mpl/insert_range.hpp> #include <boost/mpl/transform_view.hpp> #include <boost/mpl/inherit_linearly.hpp> #include <boost/type_traits/is_base_and_derived.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/facilities/intercept.hpp> #include <boost/accumulators/accumulators_fwd.hpp> #include <boost/fusion/include/next.hpp> #include <boost/fusion/include/equal_to.hpp> #include <boost/fusion/include/value_of.hpp> #include <boost/fusion/include/mpl.hpp> #include <boost/fusion/include/end.hpp> #include <boost/fusion/include/begin.hpp> #include <boost/fusion/include/cons.hpp> namespace boost { namespace accumulators { /////////////////////////////////////////////////////////////////////////// // as_feature template<typename Feature> struct as_feature { typedef Feature type; }; /////////////////////////////////////////////////////////////////////////// // weighted_feature template<typename Feature> struct as_weighted_feature { typedef Feature type; }; /////////////////////////////////////////////////////////////////////////// // feature_of template<typename Feature> struct feature_of { typedef Feature type; }; namespace detail { /////////////////////////////////////////////////////////////////////////// // feature_tag template<typename Accumulator> struct feature_tag { typedef typename Accumulator::feature_tag type; }; template<typename Feature> struct undroppable { typedef Feature type; }; template<typename Feature> struct undroppable<tag::droppable<Feature> > { typedef Feature type; }; // For the purpose of determining whether one feature depends on another, // disregard whether the feature is droppable or not. template<typename A, typename B> struct is_dependent_on : is_base_and_derived< typename undroppable<B>::type , typename undroppable<A>::type > {}; template<typename Features> struct depends_on_base : mpl::inherit_linearly< typename mpl::sort<Features, is_dependent_on<mpl::_1, mpl::_2> >::type // Don't inherit multiply from a feature , mpl::if_< is_dependent_on<mpl::_1, mpl::_2> , mpl::_1 , mpl::inherit<mpl::_1, mpl::_2> > >::type { }; } /////////////////////////////////////////////////////////////////////////// /// depends_on template<BOOST_PP_ENUM_PARAMS(BOOST_ACCUMULATORS_MAX_FEATURES, typename Feature)> struct depends_on : detail::depends_on_base< typename mpl::transform< mpl::vector<BOOST_PP_ENUM_PARAMS(BOOST_ACCUMULATORS_MAX_FEATURES, Feature)> , as_feature<mpl::_1> >::type > { typedef mpl::false_ is_weight_accumulator; typedef typename mpl::transform< mpl::vector<BOOST_PP_ENUM_PARAMS(BOOST_ACCUMULATORS_MAX_FEATURES, Feature)> , as_feature<mpl::_1> >::type dependencies; }; namespace detail { template<typename Feature> struct matches_feature { template<typename Accumulator> struct apply : is_same< typename feature_of<typename as_feature<Feature>::type>::type , typename feature_of<typename as_feature<typename feature_tag<Accumulator>::type>::type>::type > {}; }; template<typename Features, typename Accumulator> struct contains_feature_of { typedef mpl::transform_view<Features, feature_of<as_feature<mpl::_> > > features_list; typedef typename feature_of<typename feature_tag<Accumulator>::type>::type the_feature; typedef typename mpl::contains<features_list, the_feature>::type type; }; // This is to work around a bug in early versions of Fusion which caused // a compile error if contains_feature_of<List, mpl::_> is used as a // predicate to fusion::find_if template<typename Features> struct contains_feature_of_ { template<typename Accumulator> struct apply : contains_feature_of<Features, Accumulator> {}; }; template< typename First , typename Last , bool is_empty = fusion::result_of::equal_to<First, Last>::value > struct build_acc_list; template<typename First, typename Last> struct build_acc_list<First, Last, true> { typedef fusion::nil type; template<typename Args> static fusion::nil call(Args const &, First const&, Last const&) { return fusion::nil(); } }; template<typename First, typename Last> struct build_acc_list<First, Last, false> { typedef build_acc_list<typename fusion::result_of::next<First>::type, Last> next_build_acc_list; typedef fusion::cons< typename fusion::result_of::value_of<First>::type , typename next_build_acc_list::type> type; template<typename Args> static type call(Args const &args, First const& f, Last const& l) { return type(args, next_build_acc_list::call(args, fusion::next(f), l)); } }; namespace meta { template<typename Sequence> struct make_acc_list : build_acc_list< typename fusion::result_of::begin<Sequence>::type , typename fusion::result_of::end<Sequence>::type > {}; } template<typename Sequence, typename Args> typename meta::make_acc_list<Sequence>::type make_acc_list(Sequence const &seq, Args const &args) { return meta::make_acc_list<Sequence>::call(args, fusion::begin(seq), fusion::end(seq)); } /////////////////////////////////////////////////////////////////////////// // checked_as_weighted_feature template<typename Feature> struct checked_as_weighted_feature { typedef typename as_feature<Feature>::type feature_type; typedef typename as_weighted_feature<feature_type>::type type; // weighted and non-weighted flavors should provide the same feature. BOOST_MPL_ASSERT(( is_same< typename feature_of<feature_type>::type , typename feature_of<type>::type > )); }; /////////////////////////////////////////////////////////////////////////// // as_feature_list template<typename Features, typename Weight> struct as_feature_list : mpl::transform_view<Features, checked_as_weighted_feature<mpl::_1> > { }; template<typename Features> struct as_feature_list<Features, void> : mpl::transform_view<Features, as_feature<mpl::_1> > { }; /////////////////////////////////////////////////////////////////////////// // accumulator_wrapper template<typename Accumulator, typename Feature> struct accumulator_wrapper : Accumulator { typedef Feature feature_tag; accumulator_wrapper(accumulator_wrapper const &that) : Accumulator(*static_cast<Accumulator const *>(&that)) { } template<typename Args> accumulator_wrapper(Args const &args) : Accumulator(args) { } }; /////////////////////////////////////////////////////////////////////////// // to_accumulator template<typename Feature, typename Sample, typename Weight> struct to_accumulator { typedef accumulator_wrapper< typename mpl::apply2<typename Feature::impl, Sample, Weight>::type , Feature > type; }; template<typename Feature, typename Sample, typename Weight, typename Tag, typename AccumulatorSet> struct to_accumulator<Feature, Sample, tag::external<Weight, Tag, AccumulatorSet> > { BOOST_MPL_ASSERT((is_same<Tag, void>)); BOOST_MPL_ASSERT((is_same<AccumulatorSet, void>)); typedef accumulator_wrapper< typename mpl::apply2<typename Feature::impl, Sample, Weight>::type , Feature > accumulator_type; typedef typename mpl::if_< typename Feature::is_weight_accumulator , accumulator_wrapper<impl::external_impl<accumulator_type, tag::weights>, Feature> , accumulator_type >::type type; }; // BUGBUG work around a MPL bug wrt map insertion template<typename FeatureMap, typename Feature> struct insert_feature : mpl::eval_if< mpl::has_key<FeatureMap, typename feature_of<Feature>::type> , mpl::identity<FeatureMap> , mpl::insert<FeatureMap, mpl::pair<typename feature_of<Feature>::type, Feature> > > { }; template<typename FeatureMap, typename Feature, typename Weight> struct insert_dependencies : mpl::fold< as_feature_list<typename Feature::dependencies, Weight> , FeatureMap , insert_dependencies< insert_feature<mpl::_1, mpl::_2> , mpl::_2 , Weight > > { }; template<typename FeatureMap, typename Features, typename Weight> struct insert_sequence : mpl::fold< // BUGBUG should use insert_range, but doesn't seem to work for maps as_feature_list<Features, Weight> , FeatureMap , insert_feature<mpl::_1, mpl::_2> > { }; template<typename Features, typename Sample, typename Weight> struct make_accumulator_tuple { typedef typename mpl::fold< as_feature_list<Features, Weight> , mpl::map0<> , mpl::if_< mpl::is_sequence<mpl::_2> , insert_sequence<mpl::_1, mpl::_2, Weight> , insert_feature<mpl::_1, mpl::_2> > >::type feature_map; // for each element in the map, add its dependencies also typedef typename mpl::fold< feature_map , feature_map , insert_dependencies<mpl::_1, mpl::second<mpl::_2>, Weight> >::type feature_map_with_dependencies; // turn the map into a vector so we can sort it typedef typename mpl::insert_range< mpl::vector<> , mpl::end<mpl::vector<> >::type , mpl::transform_view<feature_map_with_dependencies, mpl::second<mpl::_1> > >::type feature_vector_with_dependencies; // sort the features according to which is derived from which typedef typename mpl::sort< feature_vector_with_dependencies , is_dependent_on<mpl::_2, mpl::_1> >::type sorted_feature_vector; // From the vector of features, construct a vector of accumulators typedef typename mpl::transform< sorted_feature_vector , to_accumulator<mpl::_1, Sample, Weight> >::type type; }; } // namespace detail }} // namespace boost::accumulators #endif