26 #ifndef EIGEN_STDDEQUE_H
27 #define EIGEN_STDDEQUE_H
32 #if defined(__INTEL_COMPILER) || defined(__GNUC__)
33 #define EIGEN_EXPLICIT_STL_DEQUE_INSTANTIATION(...) template class std::deque<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> >;
35 #define EIGEN_EXPLICIT_STL_DEQUE_INSTANTIATION(...)
43 #define EIGEN_DEFINE_STL_DEQUE_SPECIALIZATION(...) \
44 EIGEN_EXPLICIT_STL_DEQUE_INSTANTIATION(__VA_ARGS__) \
47 template<typename _Ay> \
48 class deque<__VA_ARGS__, _Ay> \
49 : public deque<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > \
51 typedef deque<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > deque_base; \
53 typedef __VA_ARGS__ value_type; \
54 typedef typename deque_base::allocator_type allocator_type; \
55 typedef typename deque_base::size_type size_type; \
56 typedef typename deque_base::iterator iterator; \
57 explicit deque(const allocator_type& a = allocator_type()) : deque_base(a) {} \
58 template<typename InputIterator> \
59 deque(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) : deque_base(first, last, a) {} \
60 deque(const deque& c) : deque_base(c) {} \
61 explicit deque(size_type num, const value_type& val = value_type()) : deque_base(num, val) {} \
62 deque(iterator start, iterator end) : deque_base(start, end) {} \
63 deque& operator=(const deque& x) { \
64 deque_base::operator=(x); \
71 #if !(defined(_GLIBCXX_DEQUE) && (!EIGEN_GNUC_AT_LEAST(4,1)))
75 #define EIGEN_STD_DEQUE_SPECIALIZATION_BODY \
77 typedef T value_type; \
78 typedef typename deque_base::allocator_type allocator_type; \
79 typedef typename deque_base::size_type size_type; \
80 typedef typename deque_base::iterator iterator; \
81 typedef typename deque_base::const_iterator const_iterator; \
82 explicit deque(const allocator_type& a = allocator_type()) : deque_base(a) {} \
83 template<typename InputIterator> \
84 deque(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) \
85 : deque_base(first, last, a) {} \
86 deque(const deque& c) : deque_base(c) {} \
87 explicit deque(size_type num, const value_type& val = value_type()) : deque_base(num, val) {} \
88 deque(iterator start, iterator end) : deque_base(start, end) {} \
89 deque& operator=(const deque& x) { \
90 deque_base::operator=(x); \
96 :
public deque<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T),
97 Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> >
103 void resize(size_type new_size)
104 { resize(new_size, T()); }
108 void resize(size_type new_size,
const value_type& x)
110 if (deque_base::size() < new_size)
111 deque_base::_Insert_n(deque_base::end(), new_size - deque_base::size(), x);
112 else if (new_size < deque_base::size())
113 deque_base::erase(deque_base::begin() + new_size, deque_base::end());
115 void push_back(
const value_type& x)
116 { deque_base::push_back(x); }
117 void push_front(
const value_type& x)
118 { deque_base::push_front(x); }
119 using deque_base::insert;
120 iterator insert(const_iterator position,
const value_type& x)
121 {
return deque_base::insert(position,x); }
122 void insert(const_iterator position, size_type new_size,
const value_type& x)
123 { deque_base::insert(position, new_size, x); }
124 #elif defined(_GLIBCXX_DEQUE) && EIGEN_GNUC_AT_LEAST(4,2)
126 void resize(size_type new_size,
const value_type& x)
128 if (new_size < deque_base::size())
129 deque_base::_M_erase_at_end(this->_M_impl._M_start + new_size);
131 deque_base::insert(deque_base::end(), new_size - deque_base::size(), x);
136 void resize(size_type new_size,
const value_type& x)
138 if (new_size < deque_base::size())
139 deque_base::erase(deque_base::begin() + new_size, deque_base::end());
140 else if (new_size > deque_base::size())
141 deque_base::insert(deque_base::end(), new_size - deque_base::size(), x);
147 #endif // check whether specialization is actually required
149 #endif // EIGEN_STDDEQUE_H