1 /*-----------------------------------------------------------------------------+
2 Copyright (c) 2008-2009: Joachim Faulhaber
3 +------------------------------------------------------------------------------+
4    Distributed under the Boost Software License, Version 1.0.
5       (See accompanying file LICENCE.txt or copy at
6            http://www.boost.org/LICENSE_1_0.txt)
7 +-----------------------------------------------------------------------------*/
8 #ifndef BOOST_ICL_DETAIL_INTERVAL_MORPHISM_HPP_JOFA_080315
9 #define BOOST_ICL_DETAIL_INTERVAL_MORPHISM_HPP_JOFA_080315
10 
11 #include <boost/icl/detail/notate.hpp>
12 #include <boost/icl/concept/interval_set_value.hpp>
13 #include <boost/icl/concept/element_set_value.hpp>
14 #include <boost/icl/concept/set_value.hpp>
15 #include <boost/icl/concept/map_value.hpp>
16 #include <boost/icl/associative_interval_container.hpp>
17 #include <boost/icl/associative_element_container.hpp>
18 
19 namespace boost{namespace icl
20 {
21     namespace segmental
22     {
23         template <typename ElementContainerT, typename IntervalContainerT>
atomize(ElementContainerT & result,const IntervalContainerT & src)24         void atomize(ElementContainerT& result, const IntervalContainerT& src)
25         {
26             ICL_const_FORALL(typename IntervalContainerT, itv_, src)
27             {
28                 const typename IntervalContainerT::key_type& itv   = icl::key_value<IntervalContainerT>(itv_);
29                 typename IntervalContainerT::codomain_type   coval = icl::co_value<IntervalContainerT>(itv_);
30 
31                 for(typename IntervalContainerT::domain_type element = first(itv); element <= last(itv); ++element)
32                     icl::insert(result, icl::make_value<ElementContainerT>(element, coval));
33             }
34         }
35 
36         template <typename IntervalContainerT, typename ElementContainerT>
cluster(IntervalContainerT & result,const ElementContainerT & src)37         void cluster(IntervalContainerT& result, const ElementContainerT& src)
38         {
39             typedef typename IntervalContainerT::key_type key_type;
40             ICL_const_FORALL(typename ElementContainerT, element_, src)
41             {
42                 const typename ElementContainerT::key_type&  key
43                     = key_value<ElementContainerT>(element_);
44                 const typename codomain_type_of<ElementContainerT>::type& coval
45                     = co_value<ElementContainerT>(element_);
46 
47                 result += icl::make_value<IntervalContainerT>(key_type(key), coval);
48             }
49         }
50 
51         template <typename AtomizedType, typename ClusteredType>
52         struct atomizer
53         {
operator ()boost::icl::segmental::atomizer54             void operator()(AtomizedType& atomized, const ClusteredType& clustered)
55             {
56                 segmental::atomize(atomized, clustered);
57             }
58         };
59 
60         template <typename ClusteredType, typename AtomizedType>
61         struct clusterer
62         {
operator ()boost::icl::segmental::clusterer63             void operator()(ClusteredType& clustered, const AtomizedType& atomized)
64             {
65                 segmental::cluster(clustered, atomized);
66             }
67         };
68 
69         template <typename JointType, typename SplitType>
70         struct joiner
71         {
operator ()boost::icl::segmental::joiner72             void operator()(JointType& joint, SplitType& split)
73             {
74                 icl::join(split);
75                 ICL_FORALL(typename SplitType, split_, split)
76                     joint.insert(*split_);
77             }
78         };
79 
80         template <typename AbsorberType, typename EnricherType>
81         struct identity_absorber
82         {
operator ()boost::icl::segmental::identity_absorber83             void operator()(AbsorberType& absorber, EnricherType& enricher)
84             {
85                 icl::absorb_identities(enricher);
86                 ICL_FORALL(typename EnricherType, enricher_, enricher)
87                     absorber.insert(*enricher_);
88             }
89         };
90 
91     } // namespace Interval
92 
93 
94     template<>
apply()95     inline std::string binary_template_to_string<segmental::atomizer>::apply() { return "@"; }
96     template<>
apply()97     inline std::string binary_template_to_string<segmental::clusterer>::apply() { return "&"; }
98     template<>
apply()99     inline std::string binary_template_to_string<segmental::joiner>::apply() { return "j"; }
100     template<>
apply()101     inline std::string binary_template_to_string<segmental::identity_absorber>::apply() { return "a0"; }
102 }} // namespace boost icl
103 
104 #endif // BOOST_ICL_DETAIL_INTERVAL_MORPHISM_HPP_JOFA_080315
105 
106 
107 
108