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