/*-----------------------------------------------------------------------------+ | |
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(std::less, 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 | |