/*-----------------------------------------------------------------------------+ | |
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 | |