Viewing file:  pr16688.C (5.73 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/* PR 16688. Test provided by Wolfgang Bangerth. The alias analyzer
was aborting when trying to group aliases. */
/* { dg-do compile } */
/* { dg-options "-O2" } */
template<typename _Tp>
struct iterator_traits;
template<typename _Tp>
struct iterator_traits<_Tp*> {
typedef _Tp& reference;
};
template<typename _Iterator> struct NI {
_Iterator current;
typedef typename iterator_traits<_Iterator>::reference reference;
NI() { }
NI(const _Iterator& __i) : current(__i) { }
reference operator*() const { return *current; }
NI& operator++() { return *this; }
const _Iterator& base() const { return current; }
};
template<typename _IteratorL, typename _IteratorR>
inline int
operator-(const NI<_IteratorL>& __lhs,
const NI<_IteratorR>& __rhs)
{ return __lhs.base() - __rhs.base(); }
template<typename _II, typename _OI>
inline _OI
__copy_aux(_II __first, _II __last, _OI __result)
{
struct __copy {
static _OI
copy(_II __first, _II __last, _OI __result)
{
for (; __first != __last; ++__result, ++__first)
*__result = *__first;
return __result;
}
};
return __copy::copy(__first, __last, __result);
}
struct __copy_normal
{
template<typename _II, typename _OI>
static _OI
copy_n(_II __first, _II __last, _OI __result)
{
return __copy_aux(__first, __last, __result);
}
};
template<typename _InputIterator, typename _OutputIterator>
inline _OutputIterator
copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result)
{
return __copy_normal::copy_n(__first, __last, __result);
}
template <typename T, typename U, typename V>
void uninitialized_fill_n(T,U,V);
template<typename _Tp>
struct _Vector_base {
struct _Vector_impl {
_Tp* start;
_Tp* finish;
_Tp* end_of_storage;
_Vector_impl() : start(0), finish(0), end_of_storage(0)
{ }
} impl;
_Vector_base(unsigned __n) {
impl.start = allocate(__n);
impl.finish = impl.start;
impl.end_of_storage = impl.start + __n;
}
~_Vector_base() {
deallocate(impl.start,
impl.end_of_storage - impl.start);
}
_Tp* allocate(unsigned __n);
void deallocate(_Tp* __p, unsigned __n);
NI<_Tp*> begin() { return NI<_Tp*> (impl.start); }
};
template<typename _Tp>
struct vector : _Vector_base<_Tp>
{
vector(int __n)
: _Vector_base<_Tp>(__n)
{
uninitialized_fill_n(this->impl.start, __n, _Tp());
}
};
struct Tensor
{
Tensor ();
Tensor (const Tensor &);
double values[2];
};
inline
Tensor::Tensor (const Tensor &p)
{
for (unsigned int i=0; i<2; ++i)
values[i] = p.values[i];
}
struct TriaAccessor
{
typedef void * AccessorData;
void copy_from (const TriaAccessor &);
void operator = (const TriaAccessor *);
TriaAccessor & operator = (const TriaAccessor &);
bool operator == (const TriaAccessor &) const;
bool operator != (const TriaAccessor &) const;
void operator ++ ();
int state () const;
bool used () const;
int present_level;
int present_index;
int** levels;
};
inline int TriaAccessor::state () const {
if ((present_level>=0) && (present_index>=0))
return 0;
else
if ((present_level==-1) && (present_index==-1))
return 1;
else
return 2;
}
inline
void TriaAccessor::operator ++ () {
++this->present_index;
while (this->present_index >=
static_cast<int>(*this->levels[this->present_level]))
{
++this->present_level;
this->present_index = 0;
if (this->present_level >= static_cast<int>(1))
{
this->present_level = this->present_index = -1;
return;
}
}
}
struct MGDoFObjectAccessor : TriaAccessor {};
struct TriaRawIterator
{
TriaRawIterator ();
TriaRawIterator (const TriaRawIterator &);
TriaRawIterator (const MGDoFObjectAccessor &a);
const MGDoFObjectAccessor & operator * () const;
MGDoFObjectAccessor & operator * ();
const MGDoFObjectAccessor * operator -> () const;
MGDoFObjectAccessor * operator -> ();
TriaRawIterator & operator = (const TriaRawIterator &);
bool operator == (const TriaRawIterator &) const;
bool operator != (const TriaRawIterator &) const;
bool operator < (const TriaRawIterator &) const;
MGDoFObjectAccessor accessor;
TriaRawIterator & operator ++ ();
};
struct TriaIterator : TriaRawIterator
{
TriaIterator ();
TriaIterator (const TriaIterator &i);
TriaIterator &
operator = (const TriaIterator &);
TriaIterator &
operator = (const TriaRawIterator &);
};
inline
TriaRawIterator::TriaRawIterator (const TriaRawIterator &i) :
accessor (i.accessor) {}
inline
TriaIterator::TriaIterator (const TriaIterator &i) :
TriaRawIterator (static_cast<TriaRawIterator >(i)) {}
inline
TriaRawIterator & TriaRawIterator::operator ++ () {
while (++accessor, (this->accessor.state() == 0))
if (this->accessor.used() == true)
return *this;
return *this;
}
struct Comp {
Comp (const Tensor &dir) : dir(dir) {}
bool operator () (const TriaIterator &c1, const TriaIterator &c2) const;
const Tensor dir;
};
template<typename Iter>
void x1(Iter first, Iter last, int i, Comp comp)
{
x1(Iter(), last, i, comp);
}
template<typename Iter>
inline void x2(Iter first, Iter last, Comp comp)
{
if (first.base() != last.base())
x1(first, last, (last - first), comp);
}
void downstream_dg (const Tensor& direction)
{
vector<TriaIterator> ordered_cells(13);
const Comp comparator(direction);
TriaIterator begin, end;
copy (begin, end, ordered_cells.begin());
x2 (ordered_cells.begin(), ordered_cells.begin(), comparator);
}
|
