GitHub-Proxy/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2025-07-14 17:11:50 +08:00
Code Issues Packages Projects Releases Wiki Activity

std::vector now explicitely requires the use of Eigen::aligned_allocator

Browse Source 
CREDIT Hauke Heibel
This commit is contained in:
Gael Guennebaud 2009-04-21 21:30:38 +00:00
parent c5c384cf06
commit 2697877fac
1 changed files with 65 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

152
Eigen/StdVector
View File

@ -1,41 +1,38 @@
#ifndef EIGEN_STDVECTOR_MODULE_H #ifndef EIGEN_STDVECTOR_MODULE_H
#define EIGEN_STDVECTOR_MODULE_H #define EIGEN_STDVECTOR_MODULE_H
#if defined(_GLIBCXX_VECTOR) || defined(_VECTOR_) #include "Core"
#error you must include Eigen/StdVector before std::vector
#endif
#ifndef EIGEN_GNUC_AT_LEAST
#ifdef __GNUC__
#define EIGEN_GNUC_AT_LEAST(x,y) ((__GNUC__>=x && __GNUC_MINOR__>=y) || __GNUC__>x)
#else
#define EIGEN_GNUC_AT_LEAST(x,y) 0
#endif
#endif
#define vector std_vector
#include <vector> #include <vector>
#undef vector
namespace Eigen { namespace Eigen {
template<typename T> class aligned_allocator; // This one is needed to prevent reimplementing the whole std::vector.
template <class T>
class aligned_allocator_indirection : public aligned_allocator<T>
{
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T* pointer;
typedef const T* const_pointer;
typedef T& reference;
typedef const T& const_reference;
typedef T value_type;
// meta programming to determine if a class has a given member template<class U>
struct ei_does_not_have_aligned_operator_new_marker_sizeof {int a[1];}; struct rebind
struct ei_has_aligned_operator_new_marker_sizeof {int a[2];}; {
typedef aligned_allocator_indirection<U> other;
};
template<typename ClassType> aligned_allocator_indirection() throw() {}
struct ei_has_aligned_operator_new { aligned_allocator_indirection(const aligned_allocator_indirection& ) throw() {}
template<typename T> aligned_allocator_indirection(const aligned_allocator<T>& ) throw() {}
static ei_has_aligned_operator_new_marker_sizeof template<class U>
test(T const *, typename T::ei_operator_new_marker_type const * = 0); aligned_allocator_indirection(const aligned_allocator_indirection<U>& ) throw() {}
static ei_does_not_have_aligned_operator_new_marker_sizeof template<class U>
test(...); aligned_allocator_indirection(const aligned_allocator<U>& ) throw() {}
~aligned_allocator_indirection() throw() {}
// note that the following indirection is needed for gcc-3.3
enum {ret = sizeof(test(static_cast<ClassType*>(0)))
== sizeof(ei_has_aligned_operator_new_marker_sizeof) };
}; };
#ifdef _MSC_VER #ifdef _MSC_VER
@ -43,7 +40,7 @@ struct ei_has_aligned_operator_new {
// sometimes, MSVC detects, at compile time, that the argument x // sometimes, MSVC detects, at compile time, that the argument x
// in std::vector::resize(size_t s,T x) won't be aligned and generate an error // in std::vector::resize(size_t s,T x) won't be aligned and generate an error
// even if this function is never called. Whence this little wrapper. // even if this function is never called. Whence this little wrapper.
#define _EIGEN_WORKAROUND_MSVC_STD_VECTOR(T) Eigen::ei_workaround_msvc_std_vector<T> #define EIGEN_WORKAROUND_MSVC_STD_VECTOR(T) Eigen::ei_workaround_msvc_std_vector<T>
template<typename T> struct ei_workaround_msvc_std_vector : public T template<typename T> struct ei_workaround_msvc_std_vector : public T
{ {
inline ei_workaround_msvc_std_vector() : T() {} inline ei_workaround_msvc_std_vector() : T() {}
@ -59,7 +56,7 @@ struct ei_has_aligned_operator_new {
#else #else
#define _EIGEN_WORKAROUND_MSVC_STD_VECTOR(T) T #define EIGEN_WORKAROUND_MSVC_STD_VECTOR(T) T
#endif #endif
@ -67,87 +64,68 @@ struct ei_has_aligned_operator_new {
namespace std { namespace std {
#define EIGEN_STD_VECTOR_SPECIALIZATION_BODY(VECTOR) \ #define EIGEN_STD_VECTOR_SPECIALIZATION_BODY \
public: \ public: \
typedef T value_type; \ typedef T value_type; \
typedef typename vector_base::allocator_type allocator_type; \ typedef typename vector_base::allocator_type allocator_type; \
typedef typename vector_base::size_type size_type; \ typedef typename vector_base::size_type size_type; \
typedef typename vector_base::iterator iterator; \ typedef typename vector_base::iterator iterator; \
explicit VECTOR(const allocator_type& __a = allocator_type()) : vector_base(__a) {} \ explicit vector(const allocator_type& a = allocator_type()) : vector_base(a) {} \
template<typename InputIterator> \ template<typename InputIterator> \
VECTOR(InputIterator first, InputIterator last, const allocator_type& __a = allocator_type()) \ vector(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) \
: vector_base(first, last, __a) {} \ : vector_base(first, last, a) {} \
VECTOR(const VECTOR& c) : vector_base(c) {} \ vector(const vector& c) : vector_base(c) {} \
VECTOR(size_type num, const value_type& val = value_type()) : vector_base(num, val) {} \ explicit vector(size_type num, const value_type& val = value_type()) : vector_base(num, val) {} \
VECTOR(iterator start, iterator end) : vector_base(start, end) {} \ vector(iterator start, iterator end) : vector_base(start, end) {} \
VECTOR& operator=(const VECTOR& __x) { \ vector& operator=(const vector& x) { \
vector_base::operator=(__x); \ vector_base::operator=(x); \
return *this; \ return *this; \
} }
template<typename T>
class vector<T,Eigen::aligned_allocator<T> >
template<typename T, : public vector<EIGEN_WORKAROUND_MSVC_STD_VECTOR(T),
typename AllocT = std::allocator<T>, Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STD_VECTOR(T)> >
bool HasAlignedNew = Eigen::ei_has_aligned_operator_new<T>::ret>
class ei_vector : public std::std_vector<T,AllocT>
{ {
typedef std_vector<T, AllocT> vector_base; typedef vector<EIGEN_WORKAROUND_MSVC_STD_VECTOR(T),
EIGEN_STD_VECTOR_SPECIALIZATION_BODY(ei_vector) Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STD_VECTOR(T)> > vector_base;
}; EIGEN_STD_VECTOR_SPECIALIZATION_BODY
template<typename T,typename DummyAlloc> void resize(size_type new_size)
class ei_vector<T,DummyAlloc,true> { resize(new_size, T()); }
: public std::std_vector<_EIGEN_WORKAROUND_MSVC_STD_VECTOR(T),
Eigen::aligned_allocator<_EIGEN_WORKAROUND_MSVC_STD_VECTOR(T)> >
{
typedef std_vector<_EIGEN_WORKAROUND_MSVC_STD_VECTOR(T),
Eigen::aligned_allocator<_EIGEN_WORKAROUND_MSVC_STD_VECTOR(T)> > vector_base;
EIGEN_STD_VECTOR_SPECIALIZATION_BODY(ei_vector)
void resize(size_type __new_size) #if defined(_VECTOR_)
{ resize(__new_size, T()); }
#if defined(_VECTOR_)
// workaround MSVC std::vector implementation // workaround MSVC std::vector implementation
void resize(size_type __new_size, const value_type& __x) void resize(size_type new_size, const value_type& x)
{ {
if (vector_base::size() < __new_size) if (vector_base::size() < new_size)
vector_base::_Insert_n(vector_base::end(), __new_size - vector_base::size(), __x); vector_base::_Insert_n(vector_base::end(), new_size - vector_base::size(), x);
else if (__new_size < vector_base::size()) else if (new_size < vector_base::size())
vector_base::erase(vector_base::begin() + __new_size, vector_base::end()); vector_base::erase(vector_base::begin() + new_size, vector_base::end());
} }
void push_back(const value_type& __x) void push_back(const value_type& x)
{ vector_base::push_back(__x); } { vector_base::push_back(x); }
iterator insert(iterator __position, const value_type& __x) iterator insert(iterator position, const value_type& x)
{ return vector_base::insert(__position,__x); } { return vector_base::insert(position,x); }
iterator insert(iterator __position, size_type __n, const value_type& __x) iterator insert(iterator position, size_type new_size, const value_type& x)
{ return vector_base::insert(__position, __n, __x); } { return vector_base::insert(position, new_size, x); }
#elif defined(_GLIBCXX_VECTOR) && EIGEN_GNUC_AT_LEAST(4,1) #elif defined(_GLIBCXX_VECTOR) && EIGEN_GNUC_AT_LEAST(4,1)
// workaround GCC std::vector implementation // workaround GCC std::vector implementation
// Note that before gcc-4.1 we already have: std::vector::resize(size_type,const T&), // Note that before gcc-4.1 we already have: std::vector::resize(size_type,const T&),
// no no need to workaround ! // no no need to workaround !
void resize(size_type __new_size, const value_type& __x) void resize(size_type new_size, const value_type& x)
{ {
if (__new_size < vector_base::size()) if (new_size < vector_base::size())
vector_base::_M_erase_at_end(this->_M_impl._M_start + __new_size); vector_base::_M_erase_at_end(this->_M_impl._M_start + new_size);
else else
vector_base::insert(vector_base::end(), __new_size - vector_base::size(), __x); vector_base::insert(vector_base::end(), new_size - vector_base::size(), x);
} }
#else #else
using vector_base::resize; using vector_base::resize;
#endif #endif
}; };
template<typename T,
typename AllocT = std::allocator<T> >
class vector : public ei_vector<T,AllocT>
{
typedef ei_vector<T, AllocT> vector_base;
EIGEN_STD_VECTOR_SPECIALIZATION_BODY(vector)
};
} }
#endif // EIGEN_STDVECTOR_MODULE_H #endif // EIGEN_STDVECTOR_MODULE_H