comparison DEPENDENCIES/generic/include/boost/icl/detail/interval_morphism.hpp @ 16:2665513ce2d3

Add boost headers

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