bgirgis/cpp-thirdparty
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update boost on linux

Browse Source
This commit is contained in:
Bassem Girgis
2019-08-10 16:06:25 -05:00
parent 76ad52be58
commit 861b918727
5363 changed files with 483306 additions and 116507 deletions
Download Patch File Download Diff File Expand all files Collapse all files

140
linx64/include/boost/icl/interval_base_set.hpp
View File

@@ -20,7 +20,7 @@ Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
#endif
#include <limits>
#include <boost/next_prior.hpp>
#include <boost/next_prior.hpp>
#include <boost/icl/associative_interval_container.hpp>
#include <boost/icl/type_traits/interval_type_default.hpp>
#include <boost/icl/interval.hpp>
@@ -40,14 +40,14 @@ namespace boost{namespace icl
{
/** \brief Implements a set as a set of intervals (base class) */
template
template
<
typename SubType,
typename DomainT,
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 interval_base_set
{
public:
@@ -115,7 +115,7 @@ public:
/// allocator type of the corresponding element set
typedef Alloc<DomainT> domain_allocator_type;
/// Container type for the implementation
/// Container type for the implementation
typedef typename ICL_IMPL_SPACE::set<interval_type,key_compare,allocator_type> ImplSetT;
/// key type of the implementing container
@@ -144,15 +144,15 @@ public:
typedef typename ImplSetT::const_reverse_iterator const_reverse_iterator;
/// element iterator: Depreciated, see documentation.
typedef boost::icl::element_iterator<iterator> element_iterator;
typedef boost::icl::element_iterator<iterator> element_iterator;
/// element const iterator: Depreciated, see documentation.
typedef boost::icl::element_iterator<const_iterator> element_const_iterator;
typedef boost::icl::element_iterator<const_iterator> element_const_iterator;
/// element reverse iterator: Depreciated, see documentation.
typedef boost::icl::element_iterator<reverse_iterator> element_reverse_iterator;
typedef boost::icl::element_iterator<reverse_iterator> element_reverse_iterator;
/// element const reverse iterator: Depreciated, see documentation.
typedef boost::icl::element_iterator<const_reverse_iterator> element_const_reverse_iterator;
typedef boost::icl::element_iterator<const_reverse_iterator> element_const_reverse_iterator;
BOOST_STATIC_CONSTANT(int, fineness = 0);
BOOST_STATIC_CONSTANT(int, fineness = 0);
public:
//==========================================================================
@@ -181,20 +181,20 @@ public:
}
/** Move assignment operator */
interval_base_set& operator = (interval_base_set src)
interval_base_set& operator = (interval_base_set src)
{ //call by value sice 'src' is a "sink value"
this->_set = boost::move(src._set);
return *this;
return *this;
}
//==========================================================================
# else
/** Copy assignment operator */
interval_base_set& operator = (const interval_base_set& src)
{
interval_base_set& operator = (const interval_base_set& src)
{
this->_set = src._set;
return *this;
return *this;
}
# endif // BOOST_ICL_NO_CXX11_RVALUE_REFERENCES
@@ -220,9 +220,9 @@ public:
}
/** Size of the iteration over this container */
std::size_t iterative_size()const
{
return _set.size();
std::size_t iterative_size()const
{
return _set.size();
}
//==========================================================================
@@ -231,15 +231,15 @@ public:
/** Find the interval, that contains element \c key_value */
const_iterator find(const element_type& key_value)const
{
{
return icl::find(*this, key_value);
//CL return this->_set.find(icl::singleton<segment_type>(key));
//CL return this->_set.find(icl::singleton<segment_type>(key));
}
/** Find the first interval, that collides with interval \c key_interval */
const_iterator find(const interval_type& key_interval)const
{
return this->_set.find(key_interval);
{
return this->_set.find(key_interval);
}
//==========================================================================
@@ -247,23 +247,23 @@ public:
//==========================================================================
/** Add a single element \c key to the set */
SubType& add(const element_type& key)
SubType& add(const element_type& key)
{
return icl::add(*that(), key);
}
/** Add an interval of elements \c inter_val to the set */
SubType& add(const segment_type& inter_val)
SubType& add(const segment_type& inter_val)
{
_add(inter_val);
return *that();
}
/** Add an interval of elements \c inter_val to the set. Iterator
\c prior_ is a hint to the position \c inter_val can be
/** Add an interval of elements \c inter_val to the set. Iterator
\c prior_ is a hint to the position \c inter_val can be
inserted after. */
iterator add(iterator prior_, const segment_type& inter_val)
{
iterator add(iterator prior_, const segment_type& inter_val)
{
return _add(prior_, inter_val);
}
@@ -272,35 +272,35 @@ public:
//==========================================================================
/** Subtract a single element \c key from the set */
SubType& subtract(const element_type& key)
{
SubType& subtract(const element_type& key)
{
return icl::subtract(*that(), key);
}
/** Subtract an interval of elements \c inter_val from the set */
SubType& subtract(const segment_type& inter_val);
SubType& subtract(const segment_type& inter_val);
//==========================================================================
//= Insertion
//==========================================================================
/** Insert an element \c key into the set */
SubType& insert(const element_type& key)
{
return add(key);
SubType& insert(const element_type& key)
{
return add(key);
}
/** Insert an interval of elements \c inter_val to the set */
SubType& insert(const segment_type& inter_val)
{
return add(inter_val);
SubType& insert(const segment_type& inter_val)
{
return add(inter_val);
}
/** Insert an interval of elements \c inter_val to the set. Iterator
\c prior_ is a hint to the position \c inter_val can be
/** Insert an interval of elements \c inter_val to the set. Iterator
\c prior_ is a hint to the position \c inter_val can be
inserted after. */
iterator insert(iterator prior_, const segment_type& inter_val)
{
return add(prior_, inter_val);
iterator insert(iterator prior_, const segment_type& inter_val)
{
return add(prior_, inter_val);
}
@@ -309,27 +309,27 @@ public:
//= Erasure
//==========================================================================
/** Erase an element \c key from the set */
SubType& erase(const element_type& key)
{
return subtract(key);
SubType& erase(const element_type& key)
{
return subtract(key);
}
/** Erase an interval of elements \c inter_val from the set */
SubType& erase(const segment_type& inter_val)
{
return subtract(inter_val);
SubType& erase(const segment_type& inter_val)
{
return subtract(inter_val);
}
/** Erase the interval that iterator \c position points to. */
void erase(iterator position)
{
_set.erase(position);
{
_set.erase(position);
}
/** Erase all intervals in the range <tt>[first,past)</tt> of iterators. */
void erase(iterator first, iterator past)
{
_set.erase(first, past);
{
_set.erase(first, past);
}
//==========================================================================
@@ -373,16 +373,16 @@ public:
{ return _set.upper_bound(interval); }
std::pair<iterator,iterator> equal_range(const key_type& interval)
{
{
return std::pair<iterator,iterator>
(_set.lower_bound(interval), _set.upper_bound(interval));
(_set.lower_bound(interval), _set.upper_bound(interval));
}
std::pair<const_iterator,const_iterator>
std::pair<const_iterator,const_iterator>
equal_range(const key_type& interval)const
{
{
return std::pair<const_iterator,const_iterator>
(_set.lower_bound(interval), _set.upper_bound(interval));
(_set.lower_bound(interval), _set.upper_bound(interval));
}
private:
@@ -437,7 +437,7 @@ inline void interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
if(!icl::is_empty(lead_gap))
// [lead_gap--- . . .
// [prior_) [-- it_ ...
this->_set.insert(prior(it_), lead_gap);
this->_set.insert(cyclic_prior(*this, it_), lead_gap);
// . . . --------- . . . addend interval
// [-- it_ --) has a common part with the first overval
@@ -470,7 +470,7 @@ inline void interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
// [lead_gap--- . . .
// [prior_) [-- it_ ...
this->_set.insert(prior_, lead_gap);
interval_type end_gap = left_subtract(inter_val, cur_itv);
if(!icl::is_empty(end_gap))
// [---------------end_gap)
@@ -495,12 +495,12 @@ inline void interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
//= Addition
//==============================================================================
template <class SubType, class DomainT, ICL_COMPARE Compare, ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc>
inline typename interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::iterator
inline typename interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::iterator
interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
::_add(const segment_type& addend)
{
typedef typename interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::iterator iterator;
if(icl::is_empty(addend))
if(icl::is_empty(addend))
return this->_set.end();
std::pair<iterator,bool> insertion = this->_set.insert(addend);
@@ -515,7 +515,7 @@ inline typename interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::itera
}
template <class SubType, class DomainT, ICL_COMPARE Compare, ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc>
inline typename interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::iterator
inline typename interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::iterator
interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
::_add(iterator prior_, const segment_type& addend)
{
@@ -541,11 +541,11 @@ template <class SubType, class DomainT, ICL_COMPARE Compare, ICL_INTERVAL(ICL_CO
inline SubType& interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
::subtract(const segment_type& minuend)
{
if(icl::is_empty(minuend))
if(icl::is_empty(minuend))
return *that();
std::pair<iterator, iterator> exterior = equal_range(minuend);
if(exterior.first == exterior.second)
if(exterior.first == exterior.second)
return *that();
iterator first_ = exterior.first;
@@ -553,7 +553,7 @@ inline SubType& interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
iterator last_ = prior(end_);
interval_type left_resid = right_subtract(*first_, minuend);
interval_type right_resid;
interval_type right_resid;
if(first_ != end_)
right_resid = left_subtract(*last_ , minuend);
@@ -574,17 +574,17 @@ inline SubType& interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
template<class SubType,
class DomainT, ICL_COMPARE Compare, ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc>
struct is_set<icl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> >
{
{
typedef is_set<icl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
BOOST_STATIC_CONSTANT(bool, value = true);
};
template<class SubType,
class DomainT, ICL_COMPARE Compare, ICL_INTERVAL(ICL_COMPARE) Interval, ICL_ALLOC Alloc>
struct is_interval_container<icl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> >
{
{
typedef is_interval_container<icl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
BOOST_STATIC_CONSTANT(bool, value = true);
};
@@ -592,5 +592,3 @@ struct is_interval_container<icl::interval_base_set<SubType,DomainT,Compare,Inte
}} // namespace icl boost
#endif