| /*-----------------------------------------------------------------------------+ |
| Copyright (c) 2008-2009: Joachim Faulhaber |
| +------------------------------------------------------------------------------+ |
| Distributed under the Boost Software License, Version 1.0. |
| (See accompanying file LICENCE.txt or copy at |
| http://www.boost.org/LICENSE_1_0.txt) |
| +-----------------------------------------------------------------------------*/ |
| #ifndef BOOST_ICL_DETAIL_INTERVAL_MORPHISM_HPP_JOFA_080315 |
| #define BOOST_ICL_DETAIL_INTERVAL_MORPHISM_HPP_JOFA_080315 |
| |
| #include <boost/icl/detail/notate.hpp> |
| #include <boost/icl/concept/interval_set_value.hpp> |
| #include <boost/icl/concept/element_set_value.hpp> |
| #include <boost/icl/concept/set_value.hpp> |
| #include <boost/icl/concept/map_value.hpp> |
| #include <boost/icl/associative_interval_container.hpp> |
| #include <boost/icl/associative_element_container.hpp> |
| |
| namespace boost{namespace icl |
| { |
| namespace segmental |
| { |
| template <typename ElementContainerT, typename IntervalContainerT> |
| void atomize(ElementContainerT& result, const IntervalContainerT& src) |
| { |
| ICL_const_FORALL(typename IntervalContainerT, itv_, src) |
| { |
| const typename IntervalContainerT::key_type& itv = icl::key_value<IntervalContainerT>(itv_); |
| typename IntervalContainerT::codomain_type coval = icl::co_value<IntervalContainerT>(itv_); |
| |
| for(typename IntervalContainerT::domain_type element = first(itv); element <= last(itv); ++element) |
| icl::insert(result, icl::make_value<ElementContainerT>(element, coval)); |
| } |
| } |
| |
| template <typename IntervalContainerT, typename ElementContainerT> |
| void cluster(IntervalContainerT& result, const ElementContainerT& src) |
| { |
| typedef typename IntervalContainerT::key_type key_type; |
| ICL_const_FORALL(typename ElementContainerT, element_, src) |
| { |
| const typename ElementContainerT::key_type& key |
| = key_value<ElementContainerT>(element_); |
| const typename codomain_type_of<ElementContainerT>::type& coval |
| = co_value<ElementContainerT>(element_); |
| |
| result += icl::make_value<IntervalContainerT>(key_type(key), coval); |
| } |
| } |
| |
| template <typename AtomizedType, typename ClusteredType> |
| struct atomizer |
| { |
| void operator()(AtomizedType& atomized, const ClusteredType& clustered) |
| { |
| segmental::atomize(atomized, clustered); |
| } |
| }; |
| |
| template <typename ClusteredType, typename AtomizedType> |
| struct clusterer |
| { |
| void operator()(ClusteredType& clustered, const AtomizedType& atomized) |
| { |
| segmental::cluster(clustered, atomized); |
| } |
| }; |
| |
| template <typename JointType, typename SplitType> |
| struct joiner |
| { |
| void operator()(JointType& joint, SplitType& split) |
| { |
| icl::join(split); |
| ICL_FORALL(typename SplitType, split_, split) |
| joint.insert(*split_); |
| } |
| }; |
| |
| template <typename AbsorberType, typename EnricherType> |
| struct identity_absorber |
| { |
| void operator()(AbsorberType& absorber, EnricherType& enricher) |
| { |
| icl::absorb_identities(enricher); |
| ICL_FORALL(typename EnricherType, enricher_, enricher) |
| absorber.insert(*enricher_); |
| } |
| }; |
| |
| } // namespace Interval |
| |
| |
| template<> |
| inline std::string binary_template_to_string<segmental::atomizer>::apply() { return "@"; } |
| template<> |
| inline std::string binary_template_to_string<segmental::clusterer>::apply() { return "&"; } |
| template<> |
| inline std::string binary_template_to_string<segmental::joiner>::apply() { return "j"; } |
| template<> |
| inline std::string binary_template_to_string<segmental::identity_absorber>::apply() { return "a0"; } |
| }} // namespace boost icl |
| |
| #endif // BOOST_ICL_DETAIL_INTERVAL_MORPHISM_HPP_JOFA_080315 |
| |
| |
| |