|
Go to the documentation of this file. 9 #ifndef ADOBE_VECTOR_HPP 10 #define ADOBE_VECTOR_HPP 24 #include <boost/operators.hpp> 25 #include <boost/static_assert.hpp> 26 #include <boost/type_traits/has_nothrow_constructor.hpp> 27 #include <boost/type_traits/is_integral.hpp> 28 #include <boost/utility/enable_if.hpp> 36 #include <adobe/implementation/swap.hpp> 38 #ifdef ADOBE_STD_SERIALIZATION 58 class vector : boost::totally_ordered<vector<T, A>, vector<T, A> > 85 allocator_type& allocator() { return header_m. get().allocate_finish_m.first(); } 86 const allocator_type& allocator() const { return header_m. get().allocate_finish_m.first(); } 88 pointer& finish() { return header_m. get().allocate_finish_m.second(); } 89 const pointer& finish() const { return header_m. get().allocate_finish_m.second(); } 91 pointer& end_of_storage() { return header_m. get().end_of_storage_m; } 92 const pointer& end_of_storage() const { return header_m. get().end_of_storage_m; } 99 assert(header_m != 0 || x == 0); 100 if (header_m) header_m->finish() = x; 103 const T* end_of_storage() const { return header_m ? header_m->end_of_storage() : 0; } 105 static header_t* allocate(allocator_type, std::size_t); 107 size_type remaining() const { return end_of_storage() - end(); } 109 template < typename I> 110 void append(I f, I l) { append(f, l, typename std::iterator_traits<I>::iterator_category()); } 112 template < typename I> 113 void append(I f, I l, std::input_iterator_tag); 115 template < typename I> 116 void append(I f, I l, std::forward_iterator_tag); 118 template < typename I> 119 void append_move(I f, I l) 120 { append_move(f, l, typename std::iterator_traits<I>::iterator_category()); } 122 template < typename I> 123 void append_move(I f, I l, std::input_iterator_tag); 125 template < typename I> 126 void append_move(I f, I l, std::forward_iterator_tag); 128 template < typename I> 129 iterator insert(iterator p, I f, I l, std::input_iterator_tag); 131 template < typename I> 132 iterator insert(iterator p, I f, I l, std::forward_iterator_tag); 137 explicit vector( const allocator_type& a) : header_m(allocate(a, 0)) { } 140 explicit vector(size_type n) : header_m(allocate(allocator_type(), n)) 143 set_finish( end() + n); 146 vector(size_type n, const value_type& x) : header_m(allocate(allocator_type(), n)) 148 std::uninitialized_fill_n( end(), n, x); 149 set_finish( end() + n); 152 vector(size_type n, const value_type& x, const allocator_type& a) : header_m(allocate(a, n)) 154 std::uninitialized_fill_n( end(), n, x); 155 set_finish( end() + n); 164 set_finish(std::uninitialized_copy(x. begin(), x. end(), end())); 168 template < typename I> 169 vector(I f, I l, typename boost::disable_if<boost::is_integral<I> >::type* = 0) : header_m(0) 172 template < typename I> 173 vector(I f, I l, const allocator_type& a, 174 typename boost::disable_if<boost::is_integral<I> >::type* = 0) : header_m(allocate(a), 0) 181 typename allocator_type::template rebind<char>::other alloc( get_allocator()); 182 alloc.deallocate(reinterpret_cast<char*>(header_m), 183 (end_of_storage() - begin()) * sizeof(T) + ( sizeof(header_t) - sizeof(T))); 194 iterator begin() { return header_m ? &header_m->storage_m[0] : 0; } 195 iterator end() { return header_m ? header_m->finish() : 0; } 197 const_iterator begin() const { return header_m ? &header_m->storage_m[0] : 0; } 198 const_iterator end() const { return header_m ? header_m->finish() : 0; } 228 const_reference back() const { assert(! empty()); return *( end() - 1); } 231 { append_move(&x, &x + 1); } 237 iterator insert(iterator p, value_type x) 240 template < typename I> 241 iterator insert(iterator p, I f, I l, typename boost::disable_if<boost::is_integral<I> >::type* = 0) 242 { return insert(p, f, l, typename std::iterator_traits<I>::iterator_category()); } 244 template < typename I> 247 iterator insert(iterator p, size_type n, const T& x); 249 iterator erase(iterator pos) { assert(pos != end()); return erase(pos, pos + 1); } 251 iterator erase(iterator f, iterator l); 257 void resize(size_type n, const value_type& x); 261 #if defined(_MSC_VER) && _MSC_VER == 1600 && _ITERATOR_DEBUG_LEVEL != 0 263 y. begin(), std::tr1::false_type()); 277 template < typename T, typename A> 285 typename allocator_type::template rebind<char>::other alloc(a); 287 header_t* result = reinterpret_cast<header_t* >(alloc.allocate( sizeof(header_t) - sizeof(T) 290 result->finish() = &result->storage_m[0]; 291 result->end_of_storage() = result->finish() + n; 296 template < typename T, typename A> 297 template < typename I> 300 template < typename T, typename A> 301 template < typename I> 305 template < typename T, typename A> 306 template < typename I> 312 set_finish(std::uninitialized_copy(f, l, end())); 315 template < typename T, typename A> 316 template < typename I> 325 template < typename T, typename A> 326 template < typename I> 334 return end() - s + o; 337 template < typename T, typename A> 338 template < typename I> 345 if (remaining() < n) { 348 tmp.append_move( begin(), p); 350 tmp.append_move(p, last); 356 append_move(last - n, last); 361 std::advance(m, after); 363 append_move(p, last); 367 return begin() + before + n; 370 template < typename T, typename A> 371 template < typename I> 378 if (remaining() < n) { 381 tmp.append_move( begin(), p); 382 tmp.append_move(f, l); 383 tmp.append_move(p, last); 389 append_move(last - n, last); 394 std::advance(m, after); 396 append_move(p, last); 400 return begin() + before + n; 403 template < typename T, typename A> 414 template < typename T, typename A> 420 if (remaining() < n) { 423 tmp.append_move( begin(), p); 424 std::uninitialized_fill_n(tmp. end(), n, x); 425 tmp.set_finish(tmp. end() + n); 426 tmp.append_move(p, last); 432 append_move(last - n, last); 434 std::fill_n(p, n, x); 436 std::uninitialized_fill_n(last, n - after, x); 437 set_finish(last + (n - after)); 438 append_move(p, last); 439 std::fill_n(p, after, x); 442 return begin() + before + n; 445 template < typename T, typename A> 456 template < typename T, typename A> 463 template < typename T, typename A> 467 else insert( end(), n - size(), x); 472 #ifdef ADOBE_STD_SERIALIZATION 474 template < typename T, typename A> 475 std::ostream& operator<<(std::ostream& out, const vector<T, A>& x) 510 template < typename T, typename A> 511 struct has_nothrow_constructor<adobe::version_1::vector<T, A> > : boost::mpl::true_ { };
std::pair< I, I > rotate(I f, I m, I l, std::bidirectional_iterator_tag)
friend bool operator<(const vector &x, const vector &y)
const_iterator end() const
BOOST_STATIC_ASSERT(sizeof(string_t)==sizeof(vector< char >))
basic_format< T > format(const T &t)
friend void swap(vector &x, vector &y)
bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate pred)
std::reverse_iterator< T * > reverse_iterator
move_from is used for move_ctors.
void swap(adobe::lex_stream_t &, adobe::lex_stream_t &)
const_reference front() const
reverse_iterator rbegin()
vector(I f, I l, const allocator_type &a, typename boost::disable_if< boost::is_integral< I > >::type *=0)
boost::difference_type< I >::type distance(I &range)
OutputIterator copy(const InputRange &range, OutputIterator result) copy implementation
iterator insert(iterator p, I f, I l, typename boost::disable_if< boost::is_integral< I > >::type *=0)
const_reverse_iterator rend() const
format_base::stream_type & end_sequence(format_base::stream_type &os)
std::ptrdiff_t difference_type
const_reverse_iterator rbegin() const
iterator insert_move(iterator p, I f, I l)
const T &() max(const T &a, const T &b) minmax implementation
vector(move_from< vector > x)
vector & operator=(vector x)
iterator insert(iterator p, value_type x)
format_base::stream_type & begin_sequence(format_base::stream_type &os)
vector(size_type n, const value_type &x)
F uninitialized_move(I f, I l, F r) Similar to std::uninitialized_copy but with move semantics.
size_type max_size() const
reference operator[](size_type n)
void reserve(size_type n)
vector(const allocator_type &a)
size_type capacity() const
const_reference operator[](size_type n) const
const T & const_reference
allocator_type get_allocator() const
ADOBE_NAME_TYPE_1("vector:version_1:adobe", adobe::version_1::vector< T0, adobe::capture_allocator< T0 > >) namespace boost
iterator erase(iterator pos)
bool lexicographical_compare(const InputRange1 &range1, const InputRange2 &range2) lexicographical_compare implementation
const_iterator begin() const
vector(size_type n, const value_type &x, const allocator_type &a)
std::reverse_iterator< const T * > const_reverse_iterator
vector(I f, I l, typename boost::disable_if< boost::is_integral< I > >::type *=0)
void push_back(value_type x)
ADOBE_NAME_TYPE_2("closed_hash_map:version_1:adobe", adobe::version_1::closed_hash_map< T0, T1, boost::hash< T0 >, std::equal_to< T0 >, adobe::capture_allocator< adobe::pair< T0, T1 > > >)
A runtime polymorphic type similar to boost::any which can hold any type which models Regular...
const_reference back() const
friend bool operator==(const vector &x, const vector &y)
|