devtools/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2026-04-10 11:34:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

Apply clang-format

Browse Source
This commit is contained in:
Tobias Wood
2023-11-29 11:12:48 +00:00
parent 9ea520fc45
commit f38e16c193
534 changed files with 103368 additions and 116934 deletions
Download Patch File Download Diff File Expand all files Collapse all files

606
Eigen/src/Core/StlIterators.h
View File

@@ -17,101 +17,168 @@ namespace Eigen {
namespace internal {
template<typename IteratorType>
template <typename IteratorType>
struct indexed_based_stl_iterator_traits;
template<typename Derived>
class indexed_based_stl_iterator_base
{
protected:
template <typename Derived>
class indexed_based_stl_iterator_base {
protected:
typedef indexed_based_stl_iterator_traits<Derived> traits;
typedef typename traits::XprType XprType;
typedef indexed_based_stl_iterator_base<typename traits::non_const_iterator> non_const_iterator;
typedef indexed_based_stl_iterator_base<typename traits::const_iterator> const_iterator;
typedef std::conditional_t<internal::is_const<XprType>::value,non_const_iterator,const_iterator> other_iterator;
typedef std::conditional_t<internal::is_const<XprType>::value, non_const_iterator, const_iterator> other_iterator;
// NOTE: in C++03 we cannot declare friend classes through typedefs because we need to write friend class:
friend class indexed_based_stl_iterator_base<typename traits::const_iterator>;
friend class indexed_based_stl_iterator_base<typename traits::non_const_iterator>;
public:
public:
typedef Index difference_type;
typedef std::random_access_iterator_tag iterator_category;
indexed_based_stl_iterator_base() EIGEN_NO_THROW : mp_xpr(0), m_index(0) {}
indexed_based_stl_iterator_base(XprType& xpr, Index index) EIGEN_NO_THROW : mp_xpr(&xpr), m_index(index) {}
indexed_based_stl_iterator_base(const non_const_iterator& other) EIGEN_NO_THROW
: mp_xpr(other.mp_xpr), m_index(other.m_index)
{}
indexed_based_stl_iterator_base(const non_const_iterator& other) EIGEN_NO_THROW : mp_xpr(other.mp_xpr),
m_index(other.m_index) {}
indexed_based_stl_iterator_base& operator=(const non_const_iterator& other)
{
indexed_based_stl_iterator_base& operator=(const non_const_iterator& other) {
mp_xpr = other.mp_xpr;
m_index = other.m_index;
return *this;
}
Derived& operator++() { ++m_index; return derived(); }
Derived& operator--() { --m_index; return derived(); }
Derived& operator++() {
++m_index;
return derived();
}
Derived& operator--() {
--m_index;
return derived();
}
Derived operator++(int) { Derived prev(derived()); operator++(); return prev;}
Derived operator--(int) { Derived prev(derived()); operator--(); return prev;}
Derived operator++(int) {
Derived prev(derived());
operator++();
return prev;
}
Derived operator--(int) {
Derived prev(derived());
operator--();
return prev;
}
friend Derived operator+(const indexed_based_stl_iterator_base& a, Index b) { Derived ret(a.derived()); ret += b; return ret; }
friend Derived operator-(const indexed_based_stl_iterator_base& a, Index b) { Derived ret(a.derived()); ret -= b; return ret; }
friend Derived operator+(Index a, const indexed_based_stl_iterator_base& b) { Derived ret(b.derived()); ret += a; return ret; }
friend Derived operator-(Index a, const indexed_based_stl_iterator_base& b) { Derived ret(b.derived()); ret -= a; return ret; }
Derived& operator+=(Index b) { m_index += b; return derived(); }
Derived& operator-=(Index b) { m_index -= b; return derived(); }
friend Derived operator+(const indexed_based_stl_iterator_base& a, Index b) {
Derived ret(a.derived());
ret += b;
return ret;
}
friend Derived operator-(const indexed_based_stl_iterator_base& a, Index b) {
Derived ret(a.derived());
ret -= b;
return ret;
}
friend Derived operator+(Index a, const indexed_based_stl_iterator_base& b) {
Derived ret(b.derived());
ret += a;
return ret;
}
friend Derived operator-(Index a, const indexed_based_stl_iterator_base& b) {
Derived ret(b.derived());
ret -= a;
return ret;
}
difference_type operator-(const indexed_based_stl_iterator_base& other) const
{
Derived& operator+=(Index b) {
m_index += b;
return derived();
}
Derived& operator-=(Index b) {
m_index -= b;
return derived();
}
difference_type operator-(const indexed_based_stl_iterator_base& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index - other.m_index;
}
difference_type operator-(const other_iterator& other) const
{
difference_type operator-(const other_iterator& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index - other.m_index;
}
bool operator==(const indexed_based_stl_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index == other.m_index; }
bool operator!=(const indexed_based_stl_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index != other.m_index; }
bool operator< (const indexed_based_stl_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index < other.m_index; }
bool operator<=(const indexed_based_stl_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index <= other.m_index; }
bool operator> (const indexed_based_stl_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index > other.m_index; }
bool operator>=(const indexed_based_stl_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index >= other.m_index; }
bool operator==(const indexed_based_stl_iterator_base& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index == other.m_index;
}
bool operator!=(const indexed_based_stl_iterator_base& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index != other.m_index;
}
bool operator<(const indexed_based_stl_iterator_base& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index < other.m_index;
}
bool operator<=(const indexed_based_stl_iterator_base& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index <= other.m_index;
}
bool operator>(const indexed_based_stl_iterator_base& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index > other.m_index;
}
bool operator>=(const indexed_based_stl_iterator_base& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index >= other.m_index;
}
bool operator==(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index == other.m_index; }
bool operator!=(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index != other.m_index; }
bool operator< (const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index < other.m_index; }
bool operator<=(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index <= other.m_index; }
bool operator> (const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index > other.m_index; }
bool operator>=(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index >= other.m_index; }
protected:
bool operator==(const other_iterator& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index == other.m_index;
}
bool operator!=(const other_iterator& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index != other.m_index;
}
bool operator<(const other_iterator& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index < other.m_index;
}
bool operator<=(const other_iterator& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index <= other.m_index;
}
bool operator>(const other_iterator& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index > other.m_index;
}
bool operator>=(const other_iterator& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index >= other.m_index;
}
protected:
Derived& derived() { return static_cast<Derived&>(*this); }
const Derived& derived() const { return static_cast<const Derived&>(*this); }
XprType *mp_xpr;
XprType* mp_xpr;
Index m_index;
};
template<typename Derived>
class indexed_based_stl_reverse_iterator_base
{
protected:
template <typename Derived>
class indexed_based_stl_reverse_iterator_base {
protected:
typedef indexed_based_stl_iterator_traits<Derived> traits;
typedef typename traits::XprType XprType;
typedef indexed_based_stl_reverse_iterator_base<typename traits::non_const_iterator> non_const_iterator;
typedef indexed_based_stl_reverse_iterator_base<typename traits::const_iterator> const_iterator;
typedef std::conditional_t<internal::is_const<XprType>::value,non_const_iterator,const_iterator> other_iterator;
typedef std::conditional_t<internal::is_const<XprType>::value, non_const_iterator, const_iterator> other_iterator;
// NOTE: in C++03 we cannot declare friend classes through typedefs because we need to write friend class:
friend class indexed_based_stl_reverse_iterator_base<typename traits::const_iterator>;
friend class indexed_based_stl_reverse_iterator_base<typename traits::non_const_iterator>;
public:
public:
typedef Index difference_type;
typedef std::random_access_iterator_tag iterator_category;
@@ -119,165 +186,259 @@ public:
indexed_based_stl_reverse_iterator_base(XprType& xpr, Index index) : mp_xpr(&xpr), m_index(index) {}
indexed_based_stl_reverse_iterator_base(const non_const_iterator& other)
: mp_xpr(other.mp_xpr), m_index(other.m_index)
{}
: mp_xpr(other.mp_xpr), m_index(other.m_index) {}
indexed_based_stl_reverse_iterator_base& operator=(const non_const_iterator& other)
{
indexed_based_stl_reverse_iterator_base& operator=(const non_const_iterator& other) {
mp_xpr = other.mp_xpr;
m_index = other.m_index;
return *this;
}
Derived& operator++() { --m_index; return derived(); }
Derived& operator--() { ++m_index; return derived(); }
Derived& operator++() {
--m_index;
return derived();
}
Derived& operator--() {
++m_index;
return derived();
}
Derived operator++(int) { Derived prev(derived()); operator++(); return prev;}
Derived operator--(int) { Derived prev(derived()); operator--(); return prev;}
Derived operator++(int) {
Derived prev(derived());
operator++();
return prev;
}
Derived operator--(int) {
Derived prev(derived());
operator--();
return prev;
}
friend Derived operator+(const indexed_based_stl_reverse_iterator_base& a, Index b) { Derived ret(a.derived()); ret += b; return ret; }
friend Derived operator-(const indexed_based_stl_reverse_iterator_base& a, Index b) { Derived ret(a.derived()); ret -= b; return ret; }
friend Derived operator+(Index a, const indexed_based_stl_reverse_iterator_base& b) { Derived ret(b.derived()); ret += a; return ret; }
friend Derived operator-(Index a, const indexed_based_stl_reverse_iterator_base& b) { Derived ret(b.derived()); ret -= a; return ret; }
Derived& operator+=(Index b) { m_index -= b; return derived(); }
Derived& operator-=(Index b) { m_index += b; return derived(); }
friend Derived operator+(const indexed_based_stl_reverse_iterator_base& a, Index b) {
Derived ret(a.derived());
ret += b;
return ret;
}
friend Derived operator-(const indexed_based_stl_reverse_iterator_base& a, Index b) {
Derived ret(a.derived());
ret -= b;
return ret;
}
friend Derived operator+(Index a, const indexed_based_stl_reverse_iterator_base& b) {
Derived ret(b.derived());
ret += a;
return ret;
}
friend Derived operator-(Index a, const indexed_based_stl_reverse_iterator_base& b) {
Derived ret(b.derived());
ret -= a;
return ret;
}
difference_type operator-(const indexed_based_stl_reverse_iterator_base& other) const
{
Derived& operator+=(Index b) {
m_index -= b;
return derived();
}
Derived& operator-=(Index b) {
m_index += b;
return derived();
}
difference_type operator-(const indexed_based_stl_reverse_iterator_base& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return other.m_index - m_index;
}
difference_type operator-(const other_iterator& other) const
{
difference_type operator-(const other_iterator& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return other.m_index - m_index;
}
bool operator==(const indexed_based_stl_reverse_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index == other.m_index; }
bool operator!=(const indexed_based_stl_reverse_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index != other.m_index; }
bool operator< (const indexed_based_stl_reverse_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index > other.m_index; }
bool operator<=(const indexed_based_stl_reverse_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index >= other.m_index; }
bool operator> (const indexed_based_stl_reverse_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index < other.m_index; }
bool operator>=(const indexed_based_stl_reverse_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index <= other.m_index; }
bool operator==(const indexed_based_stl_reverse_iterator_base& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index == other.m_index;
}
bool operator!=(const indexed_based_stl_reverse_iterator_base& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index != other.m_index;
}
bool operator<(const indexed_based_stl_reverse_iterator_base& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index > other.m_index;
}
bool operator<=(const indexed_based_stl_reverse_iterator_base& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index >= other.m_index;
}
bool operator>(const indexed_based_stl_reverse_iterator_base& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index < other.m_index;
}
bool operator>=(const indexed_based_stl_reverse_iterator_base& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index <= other.m_index;
}
bool operator==(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index == other.m_index; }
bool operator!=(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index != other.m_index; }
bool operator< (const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index > other.m_index; }
bool operator<=(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index >= other.m_index; }
bool operator> (const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index < other.m_index; }
bool operator>=(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index <= other.m_index; }
protected:
bool operator==(const other_iterator& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index == other.m_index;
}
bool operator!=(const other_iterator& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index != other.m_index;
}
bool operator<(const other_iterator& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index > other.m_index;
}
bool operator<=(const other_iterator& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index >= other.m_index;
}
bool operator>(const other_iterator& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index < other.m_index;
}
bool operator>=(const other_iterator& other) const {
eigen_assert(mp_xpr == other.mp_xpr);
return m_index <= other.m_index;
}
protected:
Derived& derived() { return static_cast<Derived&>(*this); }
const Derived& derived() const { return static_cast<const Derived&>(*this); }
XprType *mp_xpr;
XprType* mp_xpr;
Index m_index;
};
template<typename XprType>
class pointer_based_stl_iterator
{
enum { is_lvalue = internal::is_lvalue<XprType>::value };
template <typename XprType>
class pointer_based_stl_iterator {
enum { is_lvalue = internal::is_lvalue<XprType>::value };
typedef pointer_based_stl_iterator<std::remove_const_t<XprType>> non_const_iterator;
typedef pointer_based_stl_iterator<std::add_const_t<XprType>> const_iterator;
typedef std::conditional_t<internal::is_const<XprType>::value,non_const_iterator,const_iterator> other_iterator;
typedef std::conditional_t<internal::is_const<XprType>::value, non_const_iterator, const_iterator> other_iterator;
// NOTE: in C++03 we cannot declare friend classes through typedefs because we need to write friend class:
friend class pointer_based_stl_iterator<std::add_const_t<XprType>>;
friend class pointer_based_stl_iterator<std::remove_const_t<XprType>>;
public:
public:
typedef Index difference_type;
typedef typename XprType::Scalar value_type;
typedef std::random_access_iterator_tag iterator_category;
typedef std::conditional_t<bool(is_lvalue), value_type*, const value_type*> pointer;
typedef std::conditional_t<bool(is_lvalue), value_type&, const value_type&> reference;
pointer_based_stl_iterator() EIGEN_NO_THROW : m_ptr(0) {}
pointer_based_stl_iterator(XprType& xpr, Index index) EIGEN_NO_THROW : m_incr(xpr.innerStride())
{
pointer_based_stl_iterator(XprType& xpr, Index index) EIGEN_NO_THROW : m_incr(xpr.innerStride()) {
m_ptr = xpr.data() + index * m_incr.value();
}
pointer_based_stl_iterator(const non_const_iterator& other) EIGEN_NO_THROW
: m_ptr(other.m_ptr), m_incr(other.m_incr)
{}
pointer_based_stl_iterator(const non_const_iterator& other) EIGEN_NO_THROW : m_ptr(other.m_ptr),
m_incr(other.m_incr) {}
pointer_based_stl_iterator& operator=(const non_const_iterator& other) EIGEN_NO_THROW
{
pointer_based_stl_iterator& operator=(const non_const_iterator& other) EIGEN_NO_THROW {
m_ptr = other.m_ptr;
m_incr.setValue(other.m_incr);
return *this;
}
reference operator*() const { return *m_ptr; }
reference operator[](Index i) const { return *(m_ptr+i*m_incr.value()); }
pointer operator->() const { return m_ptr; }
reference operator*() const { return *m_ptr; }
reference operator[](Index i) const { return *(m_ptr + i * m_incr.value()); }
pointer operator->() const { return m_ptr; }
pointer_based_stl_iterator& operator++() { m_ptr += m_incr.value(); return *this; }
pointer_based_stl_iterator& operator--() { m_ptr -= m_incr.value(); return *this; }
pointer_based_stl_iterator& operator++() {
m_ptr += m_incr.value();
return *this;
}
pointer_based_stl_iterator& operator--() {
m_ptr -= m_incr.value();
return *this;
}
pointer_based_stl_iterator operator++(int) { pointer_based_stl_iterator prev(*this); operator++(); return prev;}
pointer_based_stl_iterator operator--(int) { pointer_based_stl_iterator prev(*this); operator--(); return prev;}
pointer_based_stl_iterator operator++(int) {
pointer_based_stl_iterator prev(*this);
operator++();
return prev;
}
pointer_based_stl_iterator operator--(int) {
pointer_based_stl_iterator prev(*this);
operator--();
return prev;
}
friend pointer_based_stl_iterator operator+(const pointer_based_stl_iterator& a, Index b) { pointer_based_stl_iterator ret(a); ret += b; return ret; }
friend pointer_based_stl_iterator operator-(const pointer_based_stl_iterator& a, Index b) { pointer_based_stl_iterator ret(a); ret -= b; return ret; }
friend pointer_based_stl_iterator operator+(Index a, const pointer_based_stl_iterator& b) { pointer_based_stl_iterator ret(b); ret += a; return ret; }
friend pointer_based_stl_iterator operator-(Index a, const pointer_based_stl_iterator& b) { pointer_based_stl_iterator ret(b); ret -= a; return ret; }
pointer_based_stl_iterator& operator+=(Index b) { m_ptr += b*m_incr.value(); return *this; }
pointer_based_stl_iterator& operator-=(Index b) { m_ptr -= b*m_incr.value(); return *this; }
friend pointer_based_stl_iterator operator+(const pointer_based_stl_iterator& a, Index b) {
pointer_based_stl_iterator ret(a);
ret += b;
return ret;
}
friend pointer_based_stl_iterator operator-(const pointer_based_stl_iterator& a, Index b) {
pointer_based_stl_iterator ret(a);
ret -= b;
return ret;
}
friend pointer_based_stl_iterator operator+(Index a, const pointer_based_stl_iterator& b) {
pointer_based_stl_iterator ret(b);
ret += a;
return ret;
}
friend pointer_based_stl_iterator operator-(Index a, const pointer_based_stl_iterator& b) {
pointer_based_stl_iterator ret(b);
ret -= a;
return ret;
}
pointer_based_stl_iterator& operator+=(Index b) {
m_ptr += b * m_incr.value();
return *this;
}
pointer_based_stl_iterator& operator-=(Index b) {
m_ptr -= b * m_incr.value();
return *this;
}
difference_type operator-(const pointer_based_stl_iterator& other) const {
return (m_ptr - other.m_ptr)/m_incr.value();
return (m_ptr - other.m_ptr) / m_incr.value();
}
difference_type operator-(const other_iterator& other) const {
return (m_ptr - other.m_ptr)/m_incr.value();
}
difference_type operator-(const other_iterator& other) const { return (m_ptr - other.m_ptr) / m_incr.value(); }
bool operator==(const pointer_based_stl_iterator& other) const { return m_ptr == other.m_ptr; }
bool operator!=(const pointer_based_stl_iterator& other) const { return m_ptr != other.m_ptr; }
bool operator< (const pointer_based_stl_iterator& other) const { return m_ptr < other.m_ptr; }
bool operator<(const pointer_based_stl_iterator& other) const { return m_ptr < other.m_ptr; }
bool operator<=(const pointer_based_stl_iterator& other) const { return m_ptr <= other.m_ptr; }
bool operator> (const pointer_based_stl_iterator& other) const { return m_ptr > other.m_ptr; }
bool operator>(const pointer_based_stl_iterator& other) const { return m_ptr > other.m_ptr; }
bool operator>=(const pointer_based_stl_iterator& other) const { return m_ptr >= other.m_ptr; }
bool operator==(const other_iterator& other) const { return m_ptr == other.m_ptr; }
bool operator!=(const other_iterator& other) const { return m_ptr != other.m_ptr; }
bool operator< (const other_iterator& other) const { return m_ptr < other.m_ptr; }
bool operator<(const other_iterator& other) const { return m_ptr < other.m_ptr; }
bool operator<=(const other_iterator& other) const { return m_ptr <= other.m_ptr; }
bool operator> (const other_iterator& other) const { return m_ptr > other.m_ptr; }
bool operator>(const other_iterator& other) const { return m_ptr > other.m_ptr; }
bool operator>=(const other_iterator& other) const { return m_ptr >= other.m_ptr; }
protected:
protected:
pointer m_ptr;
internal::variable_if_dynamic<Index, XprType::InnerStrideAtCompileTime> m_incr;
};
template<typename XprType_>
struct indexed_based_stl_iterator_traits<generic_randaccess_stl_iterator<XprType_> >
{
template <typename XprType_>
struct indexed_based_stl_iterator_traits<generic_randaccess_stl_iterator<XprType_>> {
typedef XprType_ XprType;
typedef generic_randaccess_stl_iterator<std::remove_const_t<XprType>> non_const_iterator;
typedef generic_randaccess_stl_iterator<std::add_const_t<XprType>> const_iterator;
};
template<typename XprType>
class generic_randaccess_stl_iterator : public indexed_based_stl_iterator_base<generic_randaccess_stl_iterator<XprType> >
{
public:
template <typename XprType>
class generic_randaccess_stl_iterator
: public indexed_based_stl_iterator_base<generic_randaccess_stl_iterator<XprType>> {
public:
typedef typename XprType::Scalar value_type;
protected:
protected:
enum {
has_direct_access = (internal::traits<XprType>::Flags & DirectAccessBit) ? 1 : 0,
is_lvalue = internal::is_lvalue<XprType>::value
is_lvalue = internal::is_lvalue<XprType>::value
};
typedef indexed_based_stl_iterator_base<generic_randaccess_stl_iterator> Base;
@@ -286,181 +447,168 @@ protected:
// TODO currently const Transpose/Reshape expressions never returns const references,
// so lets return by value too.
//typedef std::conditional_t<bool(has_direct_access), const value_type&, const value_type> read_only_ref_t;
// typedef std::conditional_t<bool(has_direct_access), const value_type&, const value_type> read_only_ref_t;
typedef const value_type read_only_ref_t;
public:
typedef std::conditional_t<bool(is_lvalue), value_type *, const value_type *> pointer;
public:
typedef std::conditional_t<bool(is_lvalue), value_type*, const value_type*> pointer;
typedef std::conditional_t<bool(is_lvalue), value_type&, read_only_ref_t> reference;
generic_randaccess_stl_iterator() : Base() {}
generic_randaccess_stl_iterator(XprType& xpr, Index index) : Base(xpr,index) {}
generic_randaccess_stl_iterator(XprType& xpr, Index index) : Base(xpr, index) {}
generic_randaccess_stl_iterator(const typename Base::non_const_iterator& other) : Base(other) {}
using Base::operator=;
reference operator*() const { return (*mp_xpr)(m_index); }
reference operator[](Index i) const { return (*mp_xpr)(m_index+i); }
pointer operator->() const { return &((*mp_xpr)(m_index)); }
reference operator*() const { return (*mp_xpr)(m_index); }
reference operator[](Index i) const { return (*mp_xpr)(m_index + i); }
pointer operator->() const { return &((*mp_xpr)(m_index)); }
};
template<typename XprType_, DirectionType Direction>
struct indexed_based_stl_iterator_traits<subvector_stl_iterator<XprType_,Direction> >
{
template <typename XprType_, DirectionType Direction>
struct indexed_based_stl_iterator_traits<subvector_stl_iterator<XprType_, Direction>> {
typedef XprType_ XprType;
typedef subvector_stl_iterator<std::remove_const_t<XprType>, Direction> non_const_iterator;
typedef subvector_stl_iterator<std::add_const_t<XprType>, Direction> const_iterator;
};
template<typename XprType, DirectionType Direction>
class subvector_stl_iterator : public indexed_based_stl_iterator_base<subvector_stl_iterator<XprType,Direction> >
{
protected:
enum { is_lvalue = internal::is_lvalue<XprType>::value };
template <typename XprType, DirectionType Direction>
class subvector_stl_iterator : public indexed_based_stl_iterator_base<subvector_stl_iterator<XprType, Direction>> {
protected:
enum { is_lvalue = internal::is_lvalue<XprType>::value };
typedef indexed_based_stl_iterator_base<subvector_stl_iterator> Base;
using Base::m_index;
using Base::mp_xpr;
typedef std::conditional_t<Direction==Vertical,typename XprType::ColXpr,typename XprType::RowXpr> SubVectorType;
typedef std::conditional_t<Direction==Vertical,typename XprType::ConstColXpr,typename XprType::ConstRowXpr> ConstSubVectorType;
typedef std::conditional_t<Direction == Vertical, typename XprType::ColXpr, typename XprType::RowXpr> SubVectorType;
typedef std::conditional_t<Direction == Vertical, typename XprType::ConstColXpr, typename XprType::ConstRowXpr>
ConstSubVectorType;
public:
public:
typedef std::conditional_t<bool(is_lvalue), SubVectorType, ConstSubVectorType> reference;
typedef typename reference::PlainObject value_type;
private:
class subvector_stl_iterator_ptr
{
public:
subvector_stl_iterator_ptr(const reference &subvector) : m_subvector(subvector) {}
reference* operator->() { return &m_subvector; }
private:
reference m_subvector;
private:
class subvector_stl_iterator_ptr {
public:
subvector_stl_iterator_ptr(const reference& subvector) : m_subvector(subvector) {}
reference* operator->() { return &m_subvector; }
private:
reference m_subvector;
};
public:
public:
typedef subvector_stl_iterator_ptr pointer;
subvector_stl_iterator() : Base() {}
subvector_stl_iterator(XprType& xpr, Index index) : Base(xpr,index) {}
reference operator*() const { return (*mp_xpr).template subVector<Direction>(m_index); }
reference operator[](Index i) const { return (*mp_xpr).template subVector<Direction>(m_index+i); }
pointer operator->() const { return (*mp_xpr).template subVector<Direction>(m_index); }
subvector_stl_iterator() : Base() {}
subvector_stl_iterator(XprType& xpr, Index index) : Base(xpr, index) {}
reference operator*() const { return (*mp_xpr).template subVector<Direction>(m_index); }
reference operator[](Index i) const { return (*mp_xpr).template subVector<Direction>(m_index + i); }
pointer operator->() const { return (*mp_xpr).template subVector<Direction>(m_index); }
};
template<typename XprType_, DirectionType Direction>
struct indexed_based_stl_iterator_traits<subvector_stl_reverse_iterator<XprType_,Direction> >
{
template <typename XprType_, DirectionType Direction>
struct indexed_based_stl_iterator_traits<subvector_stl_reverse_iterator<XprType_, Direction>> {
typedef XprType_ XprType;
typedef subvector_stl_reverse_iterator<std::remove_const_t<XprType>, Direction> non_const_iterator;
typedef subvector_stl_reverse_iterator<std::add_const_t<XprType>, Direction> const_iterator;
};
template<typename XprType, DirectionType Direction>
class subvector_stl_reverse_iterator : public indexed_based_stl_reverse_iterator_base<subvector_stl_reverse_iterator<XprType,Direction> >
{
protected:
enum { is_lvalue = internal::is_lvalue<XprType>::value };
template <typename XprType, DirectionType Direction>
class subvector_stl_reverse_iterator
: public indexed_based_stl_reverse_iterator_base<subvector_stl_reverse_iterator<XprType, Direction>> {
protected:
enum { is_lvalue = internal::is_lvalue<XprType>::value };
typedef indexed_based_stl_reverse_iterator_base<subvector_stl_reverse_iterator> Base;
using Base::m_index;
using Base::mp_xpr;
typedef std::conditional_t<Direction==Vertical,typename XprType::ColXpr,typename XprType::RowXpr> SubVectorType;
typedef std::conditional_t<Direction==Vertical,typename XprType::ConstColXpr,typename XprType::ConstRowXpr> ConstSubVectorType;
typedef std::conditional_t<Direction == Vertical, typename XprType::ColXpr, typename XprType::RowXpr> SubVectorType;
typedef std::conditional_t<Direction == Vertical, typename XprType::ConstColXpr, typename XprType::ConstRowXpr>
ConstSubVectorType;
public:
public:
typedef std::conditional_t<bool(is_lvalue), SubVectorType, ConstSubVectorType> reference;
typedef typename reference::PlainObject value_type;
private:
class subvector_stl_reverse_iterator_ptr
{
public:
subvector_stl_reverse_iterator_ptr(const reference &subvector) : m_subvector(subvector) {}
reference* operator->() { return &m_subvector; }
private:
reference m_subvector;
private:
class subvector_stl_reverse_iterator_ptr {
public:
subvector_stl_reverse_iterator_ptr(const reference& subvector) : m_subvector(subvector) {}
reference* operator->() { return &m_subvector; }
private:
reference m_subvector;
};
public:
public:
typedef subvector_stl_reverse_iterator_ptr pointer;
subvector_stl_reverse_iterator() : Base() {}
subvector_stl_reverse_iterator(XprType& xpr, Index index) : Base(xpr,index) {}
reference operator*() const { return (*mp_xpr).template subVector<Direction>(m_index); }
reference operator[](Index i) const { return (*mp_xpr).template subVector<Direction>(m_index+i); }
pointer operator->() const { return (*mp_xpr).template subVector<Direction>(m_index); }
subvector_stl_reverse_iterator() : Base() {}
subvector_stl_reverse_iterator(XprType& xpr, Index index) : Base(xpr, index) {}
reference operator*() const { return (*mp_xpr).template subVector<Direction>(m_index); }
reference operator[](Index i) const { return (*mp_xpr).template subVector<Direction>(m_index + i); }
pointer operator->() const { return (*mp_xpr).template subVector<Direction>(m_index); }
};
} // namespace internal
} // namespace internal
/** returns an iterator to the first element of the 1D vector or array
* \only_for_vectors
* \sa end(), cbegin()
*/
template<typename Derived>
inline typename DenseBase<Derived>::iterator DenseBase<Derived>::begin()
{
* \only_for_vectors
* \sa end(), cbegin()
*/
template <typename Derived>
inline typename DenseBase<Derived>::iterator DenseBase<Derived>::begin() {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
return iterator(derived(), 0);
}
/** const version of begin() */
template<typename Derived>
inline typename DenseBase<Derived>::const_iterator DenseBase<Derived>::begin() const
{
template <typename Derived>
inline typename DenseBase<Derived>::const_iterator DenseBase<Derived>::begin() const {
return cbegin();
}
/** returns a read-only const_iterator to the first element of the 1D vector or array
* \only_for_vectors
* \sa cend(), begin()
*/
template<typename Derived>
inline typename DenseBase<Derived>::const_iterator DenseBase<Derived>::cbegin() const
{
* \only_for_vectors
* \sa cend(), begin()
*/
template <typename Derived>
inline typename DenseBase<Derived>::const_iterator DenseBase<Derived>::cbegin() const {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
return const_iterator(derived(), 0);
}
/** returns an iterator to the element following the last element of the 1D vector or array
* \only_for_vectors
* \sa begin(), cend()
*/
template<typename Derived>
inline typename DenseBase<Derived>::iterator DenseBase<Derived>::end()
{
* \only_for_vectors
* \sa begin(), cend()
*/
template <typename Derived>
inline typename DenseBase<Derived>::iterator DenseBase<Derived>::end() {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
return iterator(derived(), size());
}
/** const version of end() */
template<typename Derived>
inline typename DenseBase<Derived>::const_iterator DenseBase<Derived>::end() const
{
template <typename Derived>
inline typename DenseBase<Derived>::const_iterator DenseBase<Derived>::end() const {
return cend();
}
/** returns a read-only const_iterator to the element following the last element of the 1D vector or array
* \only_for_vectors
* \sa begin(), cend()
*/
template<typename Derived>
inline typename DenseBase<Derived>::const_iterator DenseBase<Derived>::cend() const
{
* \only_for_vectors
* \sa begin(), cend()
*/
template <typename Derived>
inline typename DenseBase<Derived>::const_iterator DenseBase<Derived>::cend() const {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
return const_iterator(derived(), size());
}
} // namespace Eigen
} // namespace Eigen
#endif // EIGEN_STLITERATORS_H
#endif // EIGEN_STLITERATORS_H