Added boost header

test/external/boost/icl/separate_interval_set.hpp

@@ -0,0 +1,191 @@
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-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_SEPARATE_INTERVAL_SET_HPP_JOFA_080608
+#define BOOST_ICL_SEPARATE_INTERVAL_SET_HPP_JOFA_080608
+
+#include <boost/assert.hpp>
+#include <boost/icl/type_traits/is_interval_separator.hpp>
+#include <boost/icl/interval_base_set.hpp>
+#include <boost/icl/interval_set.hpp>
+
+namespace boost{namespace icl
+{
+
+/** \brief Implements a set as a set of intervals - leaving adjoining intervals separate */
+template 
+<
+    typename                         DomainT, 
+    ICL_COMPARE                      Compare  = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT),
+    ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, DomainT, Compare),
+    ICL_ALLOC                        Alloc    = std::allocator
+> 
+class separate_interval_set: 
+    public interval_base_set<separate_interval_set<DomainT,Compare,Interval,Alloc>,
+                             DomainT,Compare,Interval,Alloc>
+{
+public:
+    typedef separate_interval_set<DomainT,Compare,Interval,Alloc> type;
+
+    typedef interval_base_set<type,DomainT,Compare,Interval,Alloc> base_type;
+
+    typedef type overloadable_type;
+    typedef type key_object_type;
+
+    typedef interval_set<DomainT,Compare,Interval,Alloc> joint_type;
+
+    /// The domain type of the set
+    typedef DomainT   domain_type;
+    /// The codomaintype is the same as domain_type
+    typedef DomainT   codomain_type;
+
+    /// The element type of the set
+    typedef DomainT   element_type;
+    /// The interval type of the set
+    typedef ICL_INTERVAL_TYPE(Interval,DomainT,Compare) interval_type;
+    /// The segment type of the set
+    typedef interval_type   segment_type;
+
+    /// Comparison functor for domain values
+    typedef ICL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
+    /// Comparison functor for intervals
+    typedef exclusive_less_than<interval_type> interval_compare;
+
+    /// Comparison functor for keys
+    typedef exclusive_less_than<interval_type> key_compare;
+
+    /// The allocator type of the set
+    typedef Alloc<interval_type> allocator_type;
+
+    /// allocator type of the corresponding element set
+    typedef Alloc<DomainT> domain_allocator_type;
+
+    /// The corresponding atomized type representing this interval container of elements
+    typedef typename base_type::atomized_type atomized_type;
+
+    /// Container type for the implementation 
+    typedef typename base_type::ImplSetT ImplSetT;
+
+    /// key type of the implementing container
+    typedef typename ImplSetT::key_type   key_type;
+    /// data type of the implementing container
+    typedef typename ImplSetT::value_type data_type;
+    /// value type of the implementing container
+    typedef typename ImplSetT::value_type value_type;
+
+    /// iterator for iteration over intervals
+    typedef typename ImplSetT::iterator iterator;
+    /// const_iterator for iteration over intervals
+    typedef typename ImplSetT::const_iterator const_iterator;
+
+
+    enum { fineness = 2 };
+
+public:
+    //==========================================================================
+    //= Construct, copy, destruct
+    //==========================================================================
+    /// Default constructor for the empty object
+    separate_interval_set(): base_type() {}
+    /// Copy constructor
+    separate_interval_set(const separate_interval_set& src): base_type(src) {}
+
+    /// Copy constructor for base_type
+    template<class SubType>
+    separate_interval_set
+        (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& src)
+    { 
+        this->assign(src); 
+    }
+
+    /// Constructor for a single element
+    explicit separate_interval_set(const domain_type& elem): base_type() { this->add(elem); }
+    /// Constructor for a single interval
+    explicit separate_interval_set(const interval_type& itv): base_type() { this->add(itv); }
+
+    /// Assignment operator
+    template<class SubType>
+    separate_interval_set& operator =
+        (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& src)
+    { 
+        this->assign(src); 
+        return *this; 
+    }
+
+    /// Assignment from a base interval_set.
+    template<class SubType>
+    void assign(const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& src)
+    {
+        this->clear();
+        this->_set.insert(src.begin(), src.end());
+    }
+
+
+private:
+    // Private functions that shall be accessible by the baseclass:
+    friend class
+        interval_base_set<separate_interval_set<DomainT,Compare,Interval,Alloc>, 
+                                                DomainT,Compare,Interval,Alloc>;
+
+    iterator handle_inserted(iterator inserted_)
+    { 
+        return inserted_; 
+    }
+
+    iterator add_over(const interval_type& addend, iterator last_)
+    {
+        return segmental::join_under(*this, addend, last_);
+    }
+
+    iterator add_over(const interval_type& addend)
+    {
+        return segmental::join_under(*this, addend);
+    }
+
+} ;
+
+
+
+//-----------------------------------------------------------------------------
+// type traits
+//-----------------------------------------------------------------------------
+template <class DomainT, ICL_COMPARE Compare, ICL_INTERVAL(ICL_COMPARE)  Interval, ICL_ALLOC Alloc>
+struct is_set<icl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
+{ 
+    typedef is_set<icl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
+    BOOST_STATIC_CONSTANT(bool, value = true); 
+};
+
+template <class DomainT, ICL_COMPARE Compare, ICL_INTERVAL(ICL_COMPARE)  Interval, ICL_ALLOC Alloc>
+struct is_interval_container<icl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
+{ 
+    typedef is_interval_container<icl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
+    BOOST_STATIC_CONSTANT(bool, value = true); 
+};
+
+template <class DomainT, ICL_COMPARE Compare, ICL_INTERVAL(ICL_COMPARE)  Interval, ICL_ALLOC Alloc>
+struct is_interval_separator<icl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
+{ 
+    typedef is_interval_separator<icl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
+    BOOST_STATIC_CONSTANT(bool, value = true); 
+};
+
+//-----------------------------------------------------------------------------
+// type representation
+//-----------------------------------------------------------------------------
+template <class DomainT, ICL_COMPARE Compare, ICL_INTERVAL(ICL_COMPARE)  Interval, ICL_ALLOC Alloc>
+struct type_to_string<icl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
+{
+    static std::string apply()
+    { return "se_itv_set<"+ type_to_string<DomainT>::apply() +">"; }
+};
+
+}} // namespace icl boost
+
+#endif
+
+