void setnext(size_t n){
size_t nelem = v.size();
if( n != nelem ){
v = b(c);
}
next = v.begin() + n;
}
/// Check if the slice ranges
Location location(
const range_type& _a,
const range_type& _b)
{
auto _middle = _a.middle();
if (_b.max() < _middle) return LOWER; else
if (_b.min() > _middle) return UPPER;
return SAME;
}
const_iterator_pair merge_range(const range_type& key) const
{
const_iterator_pair sequence( equal_range( key ) );
if ( sequence.first != m_set.begin() && ( --sequence.first )->end() < key.begin() )
++sequence.first;
if ( sequence.second != m_set.end() && sequence.second->begin() == key.end() )
++sequence.second;
return sequence;
}
range_size_type overlapping_sum(const range_type& key) const
{
const_iterator_pair sequence( equal_range( key ) );
range_size_type sum = 0;
for ( ; sequence.first != sequence.second; ++sequence.first )
{
sum += min( sequence.first->end(), key.end() )
- max( sequence.first->begin(), key.begin() );
}
return sum;
}
fcppt::random::uniform<T, Generator>::uniform(
range_type const &_range,
Generator _gen
)
:
variate_(
_gen,
distribution(
_range.first(),
_range.last()
)
)
{}
fcppt::random::uniform<T, Generator>::uniform(
range_type const &_range
)
:
variate_(
typename boost::remove_reference<Generator>::type(
static_cast<
typename boost::remove_reference<Generator>::type::result_type
>(
fcppt::chrono::high_resolution_clock::now().time_since_epoch().count()
)
),
distribution(
_range.first(),
_range.last()
)
)
{}
range_size_type merge_and_replace(container_type& set,
iterator_pair sequence, const range_type& new_range)
{
ASSERT( sequence.first != sequence.second );
if ( sequence.first->begin() <= new_range.begin()
&& sequence.first->end() >= new_range.end() ) return 0;
range_size_type old_sum = m_length_sum;
range_size_type low = min( sequence.first->begin(), new_range.begin() );
range_size_type high = max( ( --sequence.second )->end(), new_range.end() );
for ( ++sequence.second; sequence.first != sequence.second; )
{
range_size_type length = sequence.first->size();
set.erase( sequence.first++ );
m_length_sum -= length;
}
set.insert( sequence.second, range_type( low, high ) );
m_length_sum += high - low;
return m_length_sum - old_sum;
}
void
PointAttributeDataMerger<Point>::
fill_data_helper_attr(c_array<const PainterAttribute> src,
range_type<int> src_depth_range,
c_array<PainterAttribute> dst, unsigned int &vert_dst,
range_type<int> dst_depth_range)
{
FASTUIDRAWassert(src_depth_range.difference() == dst_depth_range.difference());
for (unsigned int i = 0; i < src.size(); ++i, ++vert_dst)
{
Point P;
unsigned int d;
Point::unpack_point(&P, src[i]);
d = P.depth();
FASTUIDRAWassert(static_cast<int>(d) >= src_depth_range.m_begin);
FASTUIDRAWassert(static_cast<int>(d) < src_depth_range.m_end);
d -= src_depth_range.m_begin;
d += dst_depth_range.m_begin;
P.depth(d);
P.pack_point(&dst[vert_dst]);
}
}
size_t nth() const { return next - v.begin(); }
void operator()(const range_type& _a, const range_type& _b, range_type& _i)
{
_i(std::min(_a.min(),_b.min()),std::max(_a.max(),_b.max()));
}
void pop_front_range(const range_type &N)
{
this->V += N.size();
}
range_size_type simple_merge(container_type& set, iterator where, const range_type& new_range)
{
set.insert( where, new_range );
m_length_sum += new_range.size();
return new_range.size();
}
