FM / detail

/usr/include/boost/icl/detail

Name	Size	Mode	Actions
associated_value.hpp	1557	0644	edit dl rm
boost_config.hpp	1032	0644	edit dl rm
concept_check.hpp	958	0644	edit dl rm
design_config.hpp	5608	0644	edit dl rm
element_comparer.hpp	5736	0644	edit dl rm
element_iterator.hpp	14629	0644	edit dl rm
exclusive_less_than.hpp	1051	0644	edit dl rm
interval_map_algo.hpp	5741	0644	edit dl rm
interval_morphism.hpp	4234	0644	edit dl rm
interval_set_algo.hpp	20588	0644	edit dl rm
interval_subset_comparer.hpp	12101	0644	edit dl rm
mapped_reference.hpp	7169	0644	edit dl rm
map_algo.hpp	2659	0644	edit dl rm
notate.hpp	1687	0644	edit dl rm
on_absorbtion.hpp	1341	0644	edit dl rm
relation_state.hpp	1272	0644	edit dl rm
set_algo.hpp	4494	0644	edit dl rm
std_set.hpp	1289	0644	edit dl rm
subset_comparer.hpp	8105	0644	edit dl rm

Edit: /usr/include/boost/icl/detail/interval_morphism.hpp (4234B)

#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

/*-----------------------------------------------------------------------------+ 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 #include #include #include #include #include #include namespace boost{namespace icl { namespace segmental { template void atomize(ElementContainerT& result, const IntervalContainerT& src) { ICL_const_FORALL(typename IntervalContainerT, itv_, src) { const typename IntervalContainerT::key_type& itv = icl::key_value(itv_); typename IntervalContainerT::codomain_type coval = icl::co_value(itv_); for(typename IntervalContainerT::domain_type element = first(itv); element <= last(itv); ++element) icl::insert(result, icl::make_value(element, coval)); } } template 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(element_); const typename codomain_type_of::type& coval = co_value(element_); result += icl::make_value(key_type(key), coval); } } template struct atomizer { void operator()(AtomizedType& atomized, const ClusteredType& clustered) { segmental::atomize(atomized, clustered); } }; template struct clusterer { void operator()(ClusteredType& clustered, const AtomizedType& atomized) { segmental::cluster(clustered, atomized); } }; template struct joiner { void operator()(JointType& joint, SplitType& split) { icl::join(split); ICL_FORALL(typename SplitType, split_, split) joint.insert(*split_); } }; template 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::apply() { return "@"; } template<> inline std::string binary_template_to_string::apply() { return "&"; } template<> inline std::string binary_template_to_string::apply() { return "j"; } template<> inline std::string binary_template_to_string::apply() { return "a0"; } }} // namespace boost icl #endif // BOOST_ICL_DETAIL_INTERVAL_MORPHISM_HPP_JOFA_080315