diff options
Diffstat (limited to 'Eigen/src/StlSupport')
| -rw-r--r-- | Eigen/src/StlSupport/CMakeLists.txt | 6 | ||||
| -rw-r--r-- | Eigen/src/StlSupport/StdDeque.h | 134 | ||||
| -rw-r--r-- | Eigen/src/StlSupport/StdList.h | 114 | ||||
| -rw-r--r-- | Eigen/src/StlSupport/StdVector.h | 126 | ||||
| -rw-r--r-- | Eigen/src/StlSupport/details.h | 84 |
5 files changed, 464 insertions, 0 deletions
diff --git a/Eigen/src/StlSupport/CMakeLists.txt b/Eigen/src/StlSupport/CMakeLists.txt new file mode 100644 index 000000000..0f094f637 --- /dev/null +++ b/Eigen/src/StlSupport/CMakeLists.txt @@ -0,0 +1,6 @@ +FILE(GLOB Eigen_StlSupport_SRCS "*.h") + +INSTALL(FILES + ${Eigen_StlSupport_SRCS} + DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/StlSupport COMPONENT Devel + ) diff --git a/Eigen/src/StlSupport/StdDeque.h b/Eigen/src/StlSupport/StdDeque.h new file mode 100644 index 000000000..4ee8e5c10 --- /dev/null +++ b/Eigen/src/StlSupport/StdDeque.h @@ -0,0 +1,134 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr> +// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com> +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_STDDEQUE_H +#define EIGEN_STDDEQUE_H + +#include "Eigen/src/StlSupport/details.h" + +// Define the explicit instantiation (e.g. necessary for the Intel compiler) +#if defined(__INTEL_COMPILER) || defined(__GNUC__) + #define EIGEN_EXPLICIT_STL_DEQUE_INSTANTIATION(...) template class std::deque<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> >; +#else + #define EIGEN_EXPLICIT_STL_DEQUE_INSTANTIATION(...) +#endif + +/** + * This section contains a convenience MACRO which allows an easy specialization of + * std::deque such that for data types with alignment issues the correct allocator + * is used automatically. + */ +#define EIGEN_DEFINE_STL_DEQUE_SPECIALIZATION(...) \ +EIGEN_EXPLICIT_STL_DEQUE_INSTANTIATION(__VA_ARGS__) \ +namespace std \ +{ \ + template<typename _Ay> \ + class deque<__VA_ARGS__, _Ay> \ + : public deque<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > \ + { \ + typedef deque<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > deque_base; \ + public: \ + typedef __VA_ARGS__ value_type; \ + typedef typename deque_base::allocator_type allocator_type; \ + typedef typename deque_base::size_type size_type; \ + typedef typename deque_base::iterator iterator; \ + explicit deque(const allocator_type& a = allocator_type()) : deque_base(a) {} \ + template<typename InputIterator> \ + deque(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) : deque_base(first, last, a) {} \ + deque(const deque& c) : deque_base(c) {} \ + explicit deque(size_type num, const value_type& val = value_type()) : deque_base(num, val) {} \ + deque(iterator start, iterator end) : deque_base(start, end) {} \ + deque& operator=(const deque& x) { \ + deque_base::operator=(x); \ + return *this; \ + } \ + }; \ +} + +// check whether we really need the std::deque specialization +#if !(defined(_GLIBCXX_DEQUE) && (!EIGEN_GNUC_AT_LEAST(4,1))) /* Note that before gcc-4.1 we already have: std::deque::resize(size_type,const T&). */ + +namespace std { + +#define EIGEN_STD_DEQUE_SPECIALIZATION_BODY \ + public: \ + typedef T value_type; \ + typedef typename deque_base::allocator_type allocator_type; \ + typedef typename deque_base::size_type size_type; \ + typedef typename deque_base::iterator iterator; \ + typedef typename deque_base::const_iterator const_iterator; \ + explicit deque(const allocator_type& a = allocator_type()) : deque_base(a) {} \ + template<typename InputIterator> \ + deque(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) \ + : deque_base(first, last, a) {} \ + deque(const deque& c) : deque_base(c) {} \ + explicit deque(size_type num, const value_type& val = value_type()) : deque_base(num, val) {} \ + deque(iterator start, iterator end) : deque_base(start, end) {} \ + deque& operator=(const deque& x) { \ + deque_base::operator=(x); \ + return *this; \ + } + + template<typename T> + class deque<T,EIGEN_ALIGNED_ALLOCATOR<T> > + : public deque<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T), + Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> > +{ + typedef deque<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T), + Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> > deque_base; + EIGEN_STD_DEQUE_SPECIALIZATION_BODY + + void resize(size_type new_size) + { resize(new_size, T()); } + +#if defined(_DEQUE_) + // workaround MSVC std::deque implementation + void resize(size_type new_size, const value_type& x) + { + if (deque_base::size() < new_size) + deque_base::_Insert_n(deque_base::end(), new_size - deque_base::size(), x); + else if (new_size < deque_base::size()) + deque_base::erase(deque_base::begin() + new_size, deque_base::end()); + } + void push_back(const value_type& x) + { deque_base::push_back(x); } + void push_front(const value_type& x) + { deque_base::push_front(x); } + using deque_base::insert; + iterator insert(const_iterator position, const value_type& x) + { return deque_base::insert(position,x); } + void insert(const_iterator position, size_type new_size, const value_type& x) + { deque_base::insert(position, new_size, x); } +#elif defined(_GLIBCXX_DEQUE) && EIGEN_GNUC_AT_LEAST(4,2) + // workaround GCC std::deque implementation + void resize(size_type new_size, const value_type& x) + { + if (new_size < deque_base::size()) + deque_base::_M_erase_at_end(this->_M_impl._M_start + new_size); + else + deque_base::insert(deque_base::end(), new_size - deque_base::size(), x); + } +#else + // either GCC 4.1 or non-GCC + // default implementation which should always work. + void resize(size_type new_size, const value_type& x) + { + if (new_size < deque_base::size()) + deque_base::erase(deque_base::begin() + new_size, deque_base::end()); + else if (new_size > deque_base::size()) + deque_base::insert(deque_base::end(), new_size - deque_base::size(), x); + } +#endif + }; +} + +#endif // check whether specialization is actually required + +#endif // EIGEN_STDDEQUE_H diff --git a/Eigen/src/StlSupport/StdList.h b/Eigen/src/StlSupport/StdList.h new file mode 100644 index 000000000..627381ece --- /dev/null +++ b/Eigen/src/StlSupport/StdList.h @@ -0,0 +1,114 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com> +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_STDLIST_H +#define EIGEN_STDLIST_H + +#include "Eigen/src/StlSupport/details.h" + +// Define the explicit instantiation (e.g. necessary for the Intel compiler) +#if defined(__INTEL_COMPILER) || defined(__GNUC__) + #define EIGEN_EXPLICIT_STL_LIST_INSTANTIATION(...) template class std::list<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> >; +#else + #define EIGEN_EXPLICIT_STL_LIST_INSTANTIATION(...) +#endif + +/** + * This section contains a convenience MACRO which allows an easy specialization of + * std::list such that for data types with alignment issues the correct allocator + * is used automatically. + */ +#define EIGEN_DEFINE_STL_LIST_SPECIALIZATION(...) \ +EIGEN_EXPLICIT_STL_LIST_INSTANTIATION(__VA_ARGS__) \ +namespace std \ +{ \ + template<typename _Ay> \ + class list<__VA_ARGS__, _Ay> \ + : public list<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > \ + { \ + typedef list<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > list_base; \ + public: \ + typedef __VA_ARGS__ value_type; \ + typedef typename list_base::allocator_type allocator_type; \ + typedef typename list_base::size_type size_type; \ + typedef typename list_base::iterator iterator; \ + explicit list(const allocator_type& a = allocator_type()) : list_base(a) {} \ + template<typename InputIterator> \ + list(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) : list_base(first, last, a) {} \ + list(const list& c) : list_base(c) {} \ + explicit list(size_type num, const value_type& val = value_type()) : list_base(num, val) {} \ + list(iterator start, iterator end) : list_base(start, end) {} \ + list& operator=(const list& x) { \ + list_base::operator=(x); \ + return *this; \ + } \ + }; \ +} + +// check whether we really need the std::vector specialization +#if !(defined(_GLIBCXX_VECTOR) && (!EIGEN_GNUC_AT_LEAST(4,1))) /* Note that before gcc-4.1 we already have: std::list::resize(size_type,const T&). */ + +namespace std +{ + +#define EIGEN_STD_LIST_SPECIALIZATION_BODY \ + public: \ + typedef T value_type; \ + typedef typename list_base::allocator_type allocator_type; \ + typedef typename list_base::size_type size_type; \ + typedef typename list_base::iterator iterator; \ + typedef typename list_base::const_iterator const_iterator; \ + explicit list(const allocator_type& a = allocator_type()) : list_base(a) {} \ + template<typename InputIterator> \ + list(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) \ + : list_base(first, last, a) {} \ + list(const list& c) : list_base(c) {} \ + explicit list(size_type num, const value_type& val = value_type()) : list_base(num, val) {} \ + list(iterator start, iterator end) : list_base(start, end) {} \ + list& operator=(const list& x) { \ + list_base::operator=(x); \ + return *this; \ + } + + template<typename T> + class list<T,EIGEN_ALIGNED_ALLOCATOR<T> > + : public list<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T), + Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> > + { + typedef list<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T), + Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> > list_base; + EIGEN_STD_LIST_SPECIALIZATION_BODY + + void resize(size_type new_size) + { resize(new_size, T()); } + + void resize(size_type new_size, const value_type& x) + { + if (list_base::size() < new_size) + list_base::insert(list_base::end(), new_size - list_base::size(), x); + else + while (new_size < list_base::size()) list_base::pop_back(); + } + +#if defined(_LIST_) + // workaround MSVC std::list implementation + void push_back(const value_type& x) + { list_base::push_back(x); } + using list_base::insert; + iterator insert(const_iterator position, const value_type& x) + { return list_base::insert(position,x); } + void insert(const_iterator position, size_type new_size, const value_type& x) + { list_base::insert(position, new_size, x); } +#endif + }; +} + +#endif // check whether specialization is actually required + +#endif // EIGEN_STDLIST_H diff --git a/Eigen/src/StlSupport/StdVector.h b/Eigen/src/StlSupport/StdVector.h new file mode 100644 index 000000000..40a9abefa --- /dev/null +++ b/Eigen/src/StlSupport/StdVector.h @@ -0,0 +1,126 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr> +// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com> +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_STDVECTOR_H +#define EIGEN_STDVECTOR_H + +#include "Eigen/src/StlSupport/details.h" + +/** + * This section contains a convenience MACRO which allows an easy specialization of + * std::vector such that for data types with alignment issues the correct allocator + * is used automatically. + */ +#define EIGEN_DEFINE_STL_VECTOR_SPECIALIZATION(...) \ +namespace std \ +{ \ + template<> \ + class vector<__VA_ARGS__, std::allocator<__VA_ARGS__> > \ + : public vector<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > \ + { \ + typedef vector<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > vector_base; \ + public: \ + typedef __VA_ARGS__ value_type; \ + typedef vector_base::allocator_type allocator_type; \ + typedef vector_base::size_type size_type; \ + typedef vector_base::iterator iterator; \ + explicit vector(const allocator_type& a = allocator_type()) : vector_base(a) {} \ + template<typename InputIterator> \ + vector(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) : vector_base(first, last, a) {} \ + vector(const vector& c) : vector_base(c) {} \ + 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& operator=(const vector& x) { \ + vector_base::operator=(x); \ + return *this; \ + } \ + }; \ +} + +namespace std { + +#define EIGEN_STD_VECTOR_SPECIALIZATION_BODY \ + public: \ + typedef T value_type; \ + typedef typename vector_base::allocator_type allocator_type; \ + typedef typename vector_base::size_type size_type; \ + typedef typename vector_base::iterator iterator; \ + typedef typename vector_base::const_iterator const_iterator; \ + explicit vector(const allocator_type& a = allocator_type()) : vector_base(a) {} \ + template<typename InputIterator> \ + vector(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) \ + : vector_base(first, last, a) {} \ + vector(const vector& c) : vector_base(c) {} \ + 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& operator=(const vector& x) { \ + vector_base::operator=(x); \ + return *this; \ + } + + template<typename T> + class vector<T,EIGEN_ALIGNED_ALLOCATOR<T> > + : public vector<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T), + Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> > +{ + typedef vector<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T), + Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> > vector_base; + EIGEN_STD_VECTOR_SPECIALIZATION_BODY + + void resize(size_type new_size) + { resize(new_size, T()); } + +#if defined(_VECTOR_) + // workaround MSVC std::vector implementation + void resize(size_type new_size, const value_type& x) + { + if (vector_base::size() < new_size) + vector_base::_Insert_n(vector_base::end(), new_size - vector_base::size(), x); + else if (new_size < vector_base::size()) + vector_base::erase(vector_base::begin() + new_size, vector_base::end()); + } + void push_back(const value_type& x) + { vector_base::push_back(x); } + using vector_base::insert; + iterator insert(const_iterator position, const value_type& x) + { return vector_base::insert(position,x); } + void insert(const_iterator position, size_type new_size, const value_type& x) + { vector_base::insert(position, new_size, x); } +#elif defined(_GLIBCXX_VECTOR) && (!(EIGEN_GNUC_AT_LEAST(4,1))) + /* Note that before gcc-4.1 we already have: std::vector::resize(size_type,const T&). + * However, this specialization is still needed to make the above EIGEN_DEFINE_STL_VECTOR_SPECIALIZATION trick to work. */ + void resize(size_type new_size, const value_type& x) + { + vector_base::resize(new_size,x); + } +#elif defined(_GLIBCXX_VECTOR) && EIGEN_GNUC_AT_LEAST(4,2) + // workaround GCC std::vector implementation + void resize(size_type new_size, const value_type& x) + { + if (new_size < vector_base::size()) + vector_base::_M_erase_at_end(this->_M_impl._M_start + new_size); + else + vector_base::insert(vector_base::end(), new_size - vector_base::size(), x); + } +#else + // either GCC 4.1 or non-GCC + // default implementation which should always work. + void resize(size_type new_size, const value_type& x) + { + if (new_size < vector_base::size()) + vector_base::erase(vector_base::begin() + new_size, vector_base::end()); + else if (new_size > vector_base::size()) + vector_base::insert(vector_base::end(), new_size - vector_base::size(), x); + } +#endif + }; +} + +#endif // EIGEN_STDVECTOR_H diff --git a/Eigen/src/StlSupport/details.h b/Eigen/src/StlSupport/details.h new file mode 100644 index 000000000..d8debc7c4 --- /dev/null +++ b/Eigen/src/StlSupport/details.h @@ -0,0 +1,84 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr> +// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com> +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#ifndef EIGEN_STL_DETAILS_H +#define EIGEN_STL_DETAILS_H + +#ifndef EIGEN_ALIGNED_ALLOCATOR + #define EIGEN_ALIGNED_ALLOCATOR Eigen::aligned_allocator +#endif + +namespace Eigen { + + // This one is needed to prevent reimplementing the whole std::vector. + template <class T> + class aligned_allocator_indirection : public EIGEN_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; + + template<class U> + struct rebind + { + typedef aligned_allocator_indirection<U> other; + }; + + aligned_allocator_indirection() {} + aligned_allocator_indirection(const aligned_allocator_indirection& ) : EIGEN_ALIGNED_ALLOCATOR<T>() {} + aligned_allocator_indirection(const EIGEN_ALIGNED_ALLOCATOR<T>& ) {} + template<class U> + aligned_allocator_indirection(const aligned_allocator_indirection<U>& ) {} + template<class U> + aligned_allocator_indirection(const EIGEN_ALIGNED_ALLOCATOR<U>& ) {} + ~aligned_allocator_indirection() {} + }; + +#ifdef _MSC_VER + + // 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 + // even if this function is never called. Whence this little wrapper. +#define EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T) \ + typename Eigen::internal::conditional< \ + Eigen::internal::is_arithmetic<T>::value, \ + T, \ + Eigen::internal::workaround_msvc_stl_support<T> \ + >::type + + namespace internal { + template<typename T> struct workaround_msvc_stl_support : public T + { + inline workaround_msvc_stl_support() : T() {} + inline workaround_msvc_stl_support(const T& other) : T(other) {} + inline operator T& () { return *static_cast<T*>(this); } + inline operator const T& () const { return *static_cast<const T*>(this); } + template<typename OtherT> + inline T& operator=(const OtherT& other) + { T::operator=(other); return *this; } + inline workaround_msvc_stl_support& operator=(const workaround_msvc_stl_support& other) + { T::operator=(other); return *this; } + }; + } + +#else + +#define EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T) T + +#endif + +} + +#endif // EIGEN_STL_DETAILS_H |