00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00054 #ifndef STLSOFT_INCL_STLSOFT_CONTAINERS_HPP_POD_VECTOR
00055 #define STLSOFT_INCL_STLSOFT_CONTAINERS_HPP_POD_VECTOR
00056
00057 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00058 # define STLSOFT_VER_STLSOFT_CONTAINERS_HPP_POD_VECTOR_MAJOR 4
00059 # define STLSOFT_VER_STLSOFT_CONTAINERS_HPP_POD_VECTOR_MINOR 2
00060 # define STLSOFT_VER_STLSOFT_CONTAINERS_HPP_POD_VECTOR_REVISION 2
00061 # define STLSOFT_VER_STLSOFT_CONTAINERS_HPP_POD_VECTOR_EDIT 76
00062 #endif
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079 #ifndef STLSOFT_INCL_STLSOFT_H_STLSOFT
00080 # include <stlsoft/stlsoft.h>
00081 #endif
00082
00083 #if defined(STLSOFT_COMPILER_IS_MSVC) && \
00084 _MSC_VER < 1200
00085 # error stlsoft/containers/pod_vector.hpp is not compatible with Visual C++ 5.0 or earlier
00086 #endif
00087
00088 #ifndef STLSOFT_INCL_STLSOFT_MEMORY_HPP_AUTO_BUFFER
00089 # include <stlsoft/memory/auto_buffer.hpp>
00090 #endif
00091 #ifndef STLSOFT_INCL_STLSOFT_MEMORY_HPP_ALLOCATOR_SELECTOR
00092 # include <stlsoft/memory/allocator_selector.hpp>
00093 #endif
00094 #ifndef STLSOFT_INCL_STLSOFT_UTIL_HPP_STD_SWAP
00095 # include <stlsoft/util/std_swap.hpp>
00096 #endif
00097 #ifndef STLSOFT_INCL_STLSOFT_ALGORITHMS_HPP_POD
00098 # include <stlsoft/algorithms/pod.hpp>
00099 #endif
00100 #ifndef STLSOFT_INCL_STLSOFT_COLLECTIONS_UTIL_HPP_COLLECTIONS
00101 # include <stlsoft/collections/util/collections.hpp>
00102 #endif
00103 #ifndef STLSOFT_INCL_STLSOFT_UTIL_STD_HPP_ITERATOR_HELPER
00104 # include <stlsoft/util/std/iterator_helper.hpp>
00105 #endif
00106
00107 #ifndef STLSOFT_INCL_STDEXCEPT
00108 # define STLSOFT_INCL_STDEXCEPT
00109 # include <stdexcept>
00110 #endif
00111
00112
00113
00114
00115
00116 #ifndef _STLSOFT_NO_NAMESPACE
00117 namespace stlsoft
00118 {
00119 #endif
00120
00121
00122
00123
00124
00129 template< ss_typename_param_k T
00130 #if defined(STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_CLASS_ARGUMENT_SUPPORT) && \
00131 defined(STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_FUNDAMENTAL_ARGUMENT_SUPPORT)
00132 , ss_typename_param_k A = ss_typename_type_def_k allocator_selector<T>::allocator_type
00133 , ss_size_t SPACE = 64
00134 #else
00135 , ss_typename_param_k A
00136 , ss_size_t SPACE
00137 #endif
00138 >
00139 class pod_vector
00140 : public stl_collection_tag
00141 {
00144 private:
00145 typedef auto_buffer_old<T, A, SPACE> buffer_type_;
00146 public:
00148 typedef ss_typename_type_k buffer_type_::value_type value_type;
00150 typedef ss_typename_type_k buffer_type_::allocator_type allocator_type;
00152 typedef pod_vector<T, A, SPACE> class_type;
00154 typedef ss_typename_type_k buffer_type_::reference reference;
00156 typedef ss_typename_type_k buffer_type_::const_reference const_reference;
00158 typedef ss_typename_type_k buffer_type_::pointer pointer;
00160 typedef ss_typename_type_k buffer_type_::const_pointer const_pointer;
00162 typedef ss_typename_type_k buffer_type_::iterator iterator;
00164 typedef ss_typename_type_k buffer_type_::const_iterator const_iterator;
00165 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
00167 typedef ss_typename_type_k buffer_type_::reverse_iterator reverse_iterator;
00169 typedef ss_typename_type_k buffer_type_::const_reverse_iterator const_reverse_iterator;
00170 #endif
00172 typedef ss_typename_type_k buffer_type_::size_type size_type;
00174 typedef ss_typename_type_k buffer_type_::difference_type difference_type;
00176
00179 public:
00180 ss_explicit_k pod_vector(size_type cItems = 0);
00181 pod_vector(size_type cItems, value_type const& value);
00182 pod_vector(class_type const& rhs);
00183 pod_vector(const_iterator first, const_iterator last);
00184
00185 pod_vector& operator =(class_type const& rhs);
00187
00190 public:
00191 iterator begin();
00192 const_iterator begin() const;
00193 iterator end();
00194 const_iterator end() const;
00195 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
00196 reverse_iterator rbegin();
00197 const_reverse_iterator rbegin() const;
00198 reverse_iterator rend();
00199 const_reverse_iterator rend() const;
00200 #endif
00202
00205 public:
00206 size_type size() const;
00207 size_type capacity() const;
00208 size_type max_size() const;
00209 ss_bool_t empty() const;
00210 allocator_type get_allocator() const;
00212
00215 public:
00216 reference at(size_type index);
00217 const_reference at(size_type index) const;
00218 reference operator [](size_type index);
00219 const_reference operator [](size_type index) const;
00220 reference front();
00221 const_reference front() const;
00222 reference back();
00223 const_reference back() const;
00225
00228 public:
00229 void clear();
00230 void swap(class_type& rhs);
00231 void reserve(size_type cItems) ;
00232
00233 void resize(size_type cItems) ;
00234 void resize(size_type cItems, value_type const& value) ;
00235 void push_back(value_type const& value);
00236 void pop_back();
00237
00238 void assign(const_iterator first, const_iterator last);
00239 void assign(size_type cItems, value_type const& value = value_type());
00240 iterator insert(iterator it, value_type const& value = value_type());
00241 void insert(iterator it, size_type cItems, value_type const& value);
00242 void insert(iterator it, const_iterator first, const_iterator last);
00243 iterator erase(iterator it);
00244 iterator erase(iterator first, iterator last);
00246
00249 private:
00250 pointer begin_();
00251 const_pointer begin_() const;
00252
00253 void range_check_(size_type index) const ;
00254
00255 ss_bool_t resize_(size_type cItems) ;
00256
00257 ss_bool_t is_valid_() const;
00259
00262 private:
00263 size_type m_cItems;
00264
00265
00266 buffer_type_ m_buffer;
00268 };
00269
00270
00271
00272
00273
00274 template< ss_typename_param_k T
00275 , ss_typename_param_k A
00276 , ss_size_t SPACE
00277 >
00278 inline ss_bool_t operator ==(pod_vector<T, A, SPACE> const& lhs, pod_vector<T, A, SPACE> const& rhs)
00279 {
00280 if(lhs.size() != rhs.size())
00281 {
00282 return false;
00283 }
00284 else
00285 {
00286 #if 0
00287 for(ss_typename_type_k pod_vector<T, A, SPACE>::size_type i = 0, size = lhs.size(); i < size; ++i)
00288 {
00289 if(lhs[i] != rhs[i])
00290 {
00291 return false;
00292 }
00293 }
00294
00295 return true;
00296 #else
00297 return 0 == memcmp(&lhs[0], &rhs[0], sizeof(ss_typename_type_k pod_vector<T, A, SPACE>::size_type) * lhs.size());
00298 #endif
00299 }
00300 }
00301
00302 template< ss_typename_param_k T
00303 , ss_typename_param_k A
00304 , ss_size_t SPACE
00305 >
00306 inline ss_bool_t operator !=(pod_vector<T, A, SPACE> const& lhs, pod_vector<T, A, SPACE> const& rhs)
00307 {
00308 return !operator ==(lhs, rhs);
00309 }
00310
00311
00312
00313
00314
00315 template< ss_typename_param_k T
00316 , ss_typename_param_k A
00317 , ss_size_t SPACE
00318 >
00319 inline void swap(pod_vector<T, A, SPACE>& lhs, pod_vector<T, A, SPACE>& rhs)
00320 {
00321 lhs.swap(rhs);
00322 }
00323
00324
00325
00326
00327
00328 #ifdef STLSOFT_UNITTEST
00329 # include "./unittest/pod_vector_unittest_.h"
00330 #endif
00331
00332
00333
00334
00335
00336 #if defined(STLSOFT_COMPILER_IS_MSVC) && \
00337 _MSC_VER >= 1310
00338 # define STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED_EXCEPT_ARGS
00339 #endif
00340
00341 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00342
00343 template< ss_typename_param_k T
00344 , ss_typename_param_k A
00345 , ss_size_t SPACE
00346 >
00347 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::pointer pod_vector<T, A, SPACE>::begin_()
00348 {
00349 return m_buffer.data();
00350 }
00351
00352 template< ss_typename_param_k T
00353 , ss_typename_param_k A
00354 , ss_size_t SPACE
00355 >
00356 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::const_pointer pod_vector<T, A, SPACE>::begin_() const
00357 {
00358 return m_buffer.data();
00359 }
00360
00361 template< ss_typename_param_k T
00362 , ss_typename_param_k A
00363 , ss_size_t SPACE
00364 >
00365 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED_EXCEPT_ARGS)
00366 inline void pod_vector<T, A, SPACE>::range_check_(size_type index) const
00367 #elif defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00368 inline void pod_vector<T, A, SPACE>::range_check_(ss_typename_type_k pod_vector<T, A, SPACE>::size_type index) const
00369 #else
00370 inline void pod_vector<T, A, SPACE>::range_check_(size_type index) const
00371 #endif
00372 {
00373 # ifdef STLSOFT_CF_EXCEPTION_SUPPORT
00374 if(!(index < size()))
00375 {
00376 STLSOFT_THROW_X(stlsoft_ns_qual_std(out_of_range)("pod vector index out of range"));
00377 }
00378 #else
00379 STLSOFT_MESSAGE_ASSERT("w index out of range", index < size());
00380 #endif
00381 }
00382
00383 template< ss_typename_param_k T
00384 , ss_typename_param_k A
00385 , ss_size_t SPACE
00386 >
00387 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED_EXCEPT_ARGS)
00388 inline ss_bool_t pod_vector<T, A, SPACE>::resize_(size_type cItems)
00389 #elif defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00390 inline ss_bool_t pod_vector<T, A, SPACE>::resize_(ss_typename_type_k pod_vector<T, A, SPACE>::size_type cItems)
00391 #else
00392 inline ss_bool_t pod_vector<T, A, SPACE>::resize_(size_type cItems)
00393 #endif
00394 {
00395
00396
00397 size_type curr_capacity = capacity();
00398
00399
00400 if(cItems > curr_capacity)
00401 {
00402 size_type capacity = m_buffer.internal_size() + cItems;
00403
00404 capacity -= capacity % m_buffer.internal_size();
00405
00406 if(!m_buffer.resize(capacity))
00407 {
00408 return false;
00409 }
00410 }
00411
00412 m_cItems = cItems;
00413
00414 return true;
00415 }
00416
00417
00418 template< ss_typename_param_k T
00419 , ss_typename_param_k A
00420 , ss_size_t SPACE
00421 >
00422 inline ss_bool_t pod_vector<T, A, SPACE>::is_valid_() const
00423 {
00424 if(m_buffer.size() < m_cItems)
00425 {
00426 return false;
00427 }
00428
00429 return true;
00430 }
00431
00432
00433
00434
00435 template< ss_typename_param_k T
00436 , ss_typename_param_k A
00437 , ss_size_t SPACE
00438 >
00439 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED_EXCEPT_ARGS)
00440 inline pod_vector<T, A, SPACE>::pod_vector(size_type cItems )
00441 #elif defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00442 inline pod_vector<T, A, SPACE>::pod_vector(ss_typename_type_k pod_vector<T, A, SPACE>::size_type cItems )
00443 #else
00444 inline pod_vector<T, A, SPACE>::pod_vector(size_type cItems )
00445 #endif
00446 : m_buffer(cItems)
00447 {
00448 m_cItems = m_buffer.size();
00449
00450
00451 STLSOFT_ASSERT(is_valid_());
00452 }
00453
00454 template< ss_typename_param_k T
00455 , ss_typename_param_k A
00456 , ss_size_t SPACE
00457 >
00458 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED_EXCEPT_ARGS)
00459 inline pod_vector<T, A, SPACE>::pod_vector(size_type cItems, value_type const& value)
00460 #elif defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00461 inline pod_vector<T, A, SPACE>::pod_vector(ss_typename_type_k pod_vector<T, A, SPACE>::size_type cItems, ss_typename_type_k pod_vector<T, A, SPACE>::value_type const& value)
00462 #else
00463 inline pod_vector<T, A, SPACE>::pod_vector(size_type cItems, value_type const& value)
00464 #endif
00465 : m_buffer(cItems)
00466 {
00467 m_cItems = m_buffer.size();
00468
00469
00470 pod_fill_n(begin_(), size(), value);
00471
00472 STLSOFT_ASSERT(is_valid_());
00473 }
00474
00475 template< ss_typename_param_k T
00476 , ss_typename_param_k A
00477 , ss_size_t SPACE
00478 >
00479 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED_EXCEPT_ARGS)
00480 inline pod_vector<T, A, SPACE>::pod_vector(class_type const& rhs)
00481 #elif defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00482 inline pod_vector<T, A, SPACE>::pod_vector(ss_typename_type_k pod_vector<T, A, SPACE>::class_type const& rhs)
00483 #else
00484 inline pod_vector<T, A, SPACE>::pod_vector(class_type const& rhs)
00485 #endif
00486 : m_buffer(rhs.size())
00487 {
00488 m_cItems = m_buffer.size();
00489
00490
00491 pod_copy_n(begin_(), rhs.begin_(), size());
00492
00493 STLSOFT_ASSERT(is_valid_());
00494 }
00495
00496 template< ss_typename_param_k T
00497 , ss_typename_param_k A
00498 , ss_size_t SPACE
00499 >
00500 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED_EXCEPT_ARGS)
00501 inline pod_vector<T, A, SPACE>::pod_vector(const_iterator first, const_iterator last)
00502 #elif defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00503 inline pod_vector<T, A, SPACE>::pod_vector(ss_typename_type_k pod_vector<T, A, SPACE>::const_iterator first, ss_typename_type_k pod_vector<T, A, SPACE>::const_iterator last)
00504 #else
00505 inline pod_vector<T, A, SPACE>::pod_vector(const_iterator first, const_iterator last)
00506 #endif
00507 : m_buffer(static_cast<ss_size_t>(last - first))
00508 {
00509 m_cItems = m_buffer.size();
00510
00511
00512 if(0 != size())
00513 {
00514 pod_copy(&*first, &*last, begin_());
00515 }
00516
00517 STLSOFT_ASSERT(is_valid_());
00518 }
00519
00520 template< ss_typename_param_k T
00521 , ss_typename_param_k A
00522 , ss_size_t SPACE
00523 >
00524 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED_EXCEPT_ARGS)
00525 inline pod_vector<T, A, SPACE> &pod_vector<T, A, SPACE>::operator =(class_type const& rhs)
00526 #elif defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00527 inline pod_vector<T, A, SPACE> &pod_vector<T, A, SPACE>::operator =(ss_typename_type_k pod_vector<T, A, SPACE>::class_type const& rhs)
00528 #else
00529 inline pod_vector<T, A, SPACE> &pod_vector<T, A, SPACE>::operator =(class_type const& rhs)
00530 #endif
00531 {
00532
00533
00534 STLSOFT_ASSERT(is_valid_());
00535
00536 class_type temp(rhs);
00537
00538 temp.swap(*this);
00539
00540 STLSOFT_ASSERT(is_valid_());
00541
00542 return *this;
00543 }
00544
00545
00546
00547
00548 template< ss_typename_param_k T
00549 , ss_typename_param_k A
00550 , ss_size_t SPACE
00551 >
00552 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00553 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::iterator pod_vector<T, A, SPACE>::begin()
00554 #else
00555 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::iterator pod_vector<T, A, SPACE>::begin()
00556 #endif
00557 {
00558 STLSOFT_ASSERT(is_valid_());
00559
00560 return m_buffer.begin();
00561 }
00562
00563 template< ss_typename_param_k T
00564 , ss_typename_param_k A
00565 , ss_size_t SPACE
00566 >
00567 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00568 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::const_iterator pod_vector<T, A, SPACE>::begin() const
00569 #else
00570 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::const_iterator pod_vector<T, A, SPACE>::begin() const
00571 #endif
00572 {
00573 STLSOFT_ASSERT(is_valid_());
00574
00575 return m_buffer.begin();
00576 }
00577
00578 template< ss_typename_param_k T
00579 , ss_typename_param_k A
00580 , ss_size_t SPACE
00581 >
00582 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00583 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::iterator pod_vector<T, A, SPACE>::end()
00584 #else
00585 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::iterator pod_vector<T, A, SPACE>::end()
00586 #endif
00587 {
00588 STLSOFT_ASSERT(is_valid_());
00589
00590 return &begin_()[size()];
00591 }
00592
00593 template< ss_typename_param_k T
00594 , ss_typename_param_k A
00595 , ss_size_t SPACE
00596 >
00597 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00598 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::const_iterator pod_vector<T, A, SPACE>::end() const
00599 #else
00600 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::const_iterator pod_vector<T, A, SPACE>::end() const
00601 #endif
00602 {
00603 STLSOFT_ASSERT(is_valid_());
00604
00605 return &begin_()[size()];
00606 }
00607
00608 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
00609 template< ss_typename_param_k T
00610 , ss_typename_param_k A
00611 , ss_size_t SPACE
00612 >
00613 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00614 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::reverse_iterator pod_vector<T, A, SPACE>::rbegin()
00615 #else
00616 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::reverse_iterator pod_vector<T, A, SPACE>::rbegin()
00617 #endif
00618 {
00619 STLSOFT_ASSERT(is_valid_());
00620
00621 return reverse_iterator(end());
00622 }
00623
00624 template< ss_typename_param_k T
00625 , ss_typename_param_k A
00626 , ss_size_t SPACE
00627 >
00628 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00629 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::const_reverse_iterator pod_vector<T, A, SPACE>::rbegin() const
00630 #else
00631 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::const_reverse_iterator pod_vector<T, A, SPACE>::rbegin() const
00632 #endif
00633 {
00634 STLSOFT_ASSERT(is_valid_());
00635
00636 return const_reverse_iterator(end());
00637 }
00638
00639 template< ss_typename_param_k T
00640 , ss_typename_param_k A
00641 , ss_size_t SPACE
00642 >
00643 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00644 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::reverse_iterator pod_vector<T, A, SPACE>::rend()
00645 #else
00646 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::reverse_iterator pod_vector<T, A, SPACE>::rend()
00647 #endif
00648 {
00649 STLSOFT_ASSERT(is_valid_());
00650
00651 return reverse_iterator(begin());
00652 }
00653
00654 template< ss_typename_param_k T
00655 , ss_typename_param_k A
00656 , ss_size_t SPACE
00657 >
00658 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00659 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::const_reverse_iterator pod_vector<T, A, SPACE>::rend() const
00660 #else
00661 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::const_reverse_iterator pod_vector<T, A, SPACE>::rend() const
00662 #endif
00663 {
00664 STLSOFT_ASSERT(is_valid_());
00665
00666 return const_reverse_iterator(begin());
00667 }
00668 #endif
00669
00670
00671
00672 template< ss_typename_param_k T
00673 , ss_typename_param_k A
00674 , ss_size_t SPACE
00675 >
00676 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00677 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::size_type pod_vector<T, A, SPACE>::size() const
00678 #else
00679 inline ss_size_t pod_vector<T, A, SPACE>::size() const
00680 #endif
00681 {
00682 STLSOFT_ASSERT(is_valid_());
00683
00684 return m_cItems;
00685 }
00686
00687 template< ss_typename_param_k T
00688 , ss_typename_param_k A
00689 , ss_size_t SPACE
00690 >
00691 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00692 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::size_type pod_vector<T, A, SPACE>::capacity() const
00693 #else
00694 inline ss_size_t pod_vector<T, A, SPACE>::capacity() const
00695 #endif
00696 {
00697 STLSOFT_ASSERT(is_valid_());
00698
00699 return m_buffer.size();
00700 }
00701
00702 template< ss_typename_param_k T
00703 , ss_typename_param_k A
00704 , ss_size_t SPACE
00705 >
00706 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00707 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::size_type pod_vector<T, A, SPACE>::max_size() const
00708 #else
00709 inline ss_size_t pod_vector<T, A, SPACE>::max_size() const
00710 #endif
00711 {
00712 STLSOFT_ASSERT(is_valid_());
00713
00714 return static_cast<size_type>(-1) / sizeof(value_type);
00715 }
00716
00717 template< ss_typename_param_k T
00718 , ss_typename_param_k A
00719 , ss_size_t SPACE
00720 >
00721 inline ss_bool_t pod_vector<T, A, SPACE>::empty() const
00722 {
00723 STLSOFT_ASSERT(is_valid_());
00724
00725 return 0 == size();
00726 }
00727
00728 template< ss_typename_param_k T
00729 , ss_typename_param_k A
00730 , ss_size_t SPACE
00731 >
00732 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00733 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::allocator_type pod_vector<T, A, SPACE>::get_allocator() const
00734 #else
00735 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::allocator_type pod_vector<T, A, SPACE>::get_allocator() const
00736 #endif
00737 {
00738 STLSOFT_ASSERT(is_valid_());
00739
00740 return m_buffer.get_allocator();
00741 }
00742
00743
00744 template< ss_typename_param_k T
00745 , ss_typename_param_k A
00746 , ss_size_t SPACE
00747 >
00748 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED_EXCEPT_ARGS)
00749 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::reference pod_vector<T, A, SPACE>::at(size_type index)
00750 #elif defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00751 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::reference pod_vector<T, A, SPACE>::at(ss_typename_type_k pod_vector<T, A, SPACE>::size_type index)
00752 #else
00753 inline T &pod_vector<T, A, SPACE>::at(size_type index)
00754 #endif
00755 {
00756 STLSOFT_ASSERT(is_valid_());
00757
00758 range_check_(index);
00759
00760 STLSOFT_ASSERT(is_valid_());
00761
00762 return begin_()[index];
00763 }
00764
00765 template< ss_typename_param_k T
00766 , ss_typename_param_k A
00767 , ss_size_t SPACE
00768 >
00769 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED_EXCEPT_ARGS)
00770 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::const_reference pod_vector<T, A, SPACE>::at(size_type index) const
00771 #elif defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00772 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::const_reference pod_vector<T, A, SPACE>::at(ss_typename_type_k pod_vector<T, A, SPACE>::size_type index) const
00773 #else
00774 inline T const& pod_vector<T, A, SPACE>::at(size_type index) const
00775 #endif
00776 {
00777 STLSOFT_ASSERT(is_valid_());
00778
00779 range_check_(index);
00780
00781 STLSOFT_ASSERT(is_valid_());
00782
00783 return begin_()[index];
00784 }
00785
00786 template< ss_typename_param_k T
00787 , ss_typename_param_k A
00788 , ss_size_t SPACE
00789 >
00790 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED_EXCEPT_ARGS)
00791 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::reference pod_vector<T, A, SPACE>::operator [](size_type index)
00792 #elif defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00793 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::reference pod_vector<T, A, SPACE>::operator [](ss_typename_type_k pod_vector<T, A, SPACE>::size_type index)
00794 #else
00795 inline T &pod_vector<T, A, SPACE>::operator [](size_type index)
00796 #endif
00797 {
00798 STLSOFT_ASSERT(is_valid_());
00799
00800
00801
00802 STLSOFT_MESSAGE_ASSERT("Requested index is out of range", !(size() < index));
00803
00804 return begin_()[index];
00805 }
00806
00807 template< ss_typename_param_k T
00808 , ss_typename_param_k A
00809 , ss_size_t SPACE
00810 >
00811 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED_EXCEPT_ARGS)
00812 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::const_reference pod_vector<T, A, SPACE>::operator [](size_type index) const
00813 #elif defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00814 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::const_reference pod_vector<T, A, SPACE>::operator [](ss_typename_type_k pod_vector<T, A, SPACE>::size_type index) const
00815 #else
00816 inline T const& pod_vector<T, A, SPACE>::operator [](size_type index) const
00817 #endif
00818 {
00819 STLSOFT_ASSERT(is_valid_());
00820
00821 STLSOFT_MESSAGE_ASSERT("Requested index is out of range", index < size());
00822
00823 return begin_()[index];
00824 }
00825
00826 template< ss_typename_param_k T
00827 , ss_typename_param_k A
00828 , ss_size_t SPACE
00829 >
00830 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED_EXCEPT_ARGS)
00831 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::reference pod_vector<T, A, SPACE>::front()
00832 #elif defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00833 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::reference pod_vector<T, A, SPACE>::front()
00834 #else
00835 inline T &pod_vector<T, A, SPACE>::front()
00836 #endif
00837 {
00838 STLSOFT_ASSERT(is_valid_());
00839
00840 STLSOFT_MESSAGE_ASSERT("Range is empty!", 0 != size());
00841
00842 return begin_()[0];
00843 }
00844
00845 template< ss_typename_param_k T
00846 , ss_typename_param_k A
00847 , ss_size_t SPACE
00848 >
00849 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED_EXCEPT_ARGS)
00850 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::const_reference pod_vector<T, A, SPACE>::front() const
00851 #elif defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00852 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::const_reference pod_vector<T, A, SPACE>::front() const
00853 #else
00854 inline T const& pod_vector<T, A, SPACE>::front() const
00855 #endif
00856 {
00857 STLSOFT_ASSERT(is_valid_());
00858
00859 STLSOFT_MESSAGE_ASSERT("Range is empty!", 0 != size());
00860
00861 return begin_()[0];
00862 }
00863
00864 template< ss_typename_param_k T
00865 , ss_typename_param_k A
00866 , ss_size_t SPACE
00867 >
00868 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED_EXCEPT_ARGS)
00869 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::reference pod_vector<T, A, SPACE>::back()
00870 #elif defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00871 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::reference pod_vector<T, A, SPACE>::back()
00872 #else
00873 inline T &pod_vector<T, A, SPACE>::back()
00874 #endif
00875 {
00876 STLSOFT_ASSERT(is_valid_());
00877
00878 STLSOFT_MESSAGE_ASSERT("Range is empty!", 0 != size());
00879
00880 return begin_()[size() - 1];
00881 }
00882
00883
00884 template< ss_typename_param_k T
00885 , ss_typename_param_k A
00886 , ss_size_t SPACE
00887 >
00888 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED_EXCEPT_ARGS)
00889 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::const_reference pod_vector<T, A, SPACE>::back() const
00890 #elif defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00891 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::const_reference pod_vector<T, A, SPACE>::back() const
00892 #else
00893 inline T const& pod_vector<T, A, SPACE>::back() const
00894 #endif
00895 {
00896 STLSOFT_ASSERT(is_valid_());
00897
00898 STLSOFT_MESSAGE_ASSERT("Range is empty!", 0 != size());
00899
00900 return begin_()[size() - 1];
00901 }
00902
00903
00904
00905 template< ss_typename_param_k T
00906 , ss_typename_param_k A
00907 , ss_size_t SPACE
00908 >
00909 inline void pod_vector<T, A, SPACE>::clear()
00910 {
00911 STLSOFT_ASSERT(is_valid_());
00912
00913 if(m_buffer.resize(0))
00914 {
00915 m_cItems = 0;
00916 }
00917
00918 STLSOFT_ASSERT(is_valid_());
00919 }
00920
00921 template< ss_typename_param_k T
00922 , ss_typename_param_k A
00923 , ss_size_t SPACE
00924 >
00925 inline void pod_vector<T, A, SPACE>::swap(pod_vector<T, A, SPACE>& rhs)
00926 {
00927 STLSOFT_ASSERT(is_valid_());
00928
00929 m_buffer.swap(rhs.m_buffer);
00930 std_swap(m_cItems, rhs.m_cItems);
00931
00932 STLSOFT_ASSERT(is_valid_());
00933 }
00934
00935 template< ss_typename_param_k T
00936 , ss_typename_param_k A
00937 , ss_size_t SPACE
00938 >
00939 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00940 inline void pod_vector<T, A, SPACE>::reserve(ss_typename_type_k pod_vector<T, A, SPACE>::size_type cItems)
00941 #else
00942 inline void pod_vector<T, A, SPACE>::reserve(size_type cItems)
00943 #endif
00944 {
00945 STLSOFT_ASSERT(is_valid_());
00946
00947
00948
00949 if( 0 == cItems ||
00950 cItems > size())
00951 {
00952 m_buffer.resize(cItems);
00953 }
00954
00955 STLSOFT_ASSERT(is_valid_());
00956 }
00957
00958 template< ss_typename_param_k T
00959 , ss_typename_param_k A
00960 , ss_size_t SPACE
00961 >
00962 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00963 inline void pod_vector<T, A, SPACE>::resize(ss_typename_type_k pod_vector<T, A, SPACE>::size_type cItems)
00964 #else
00965 inline void pod_vector<T, A, SPACE>::resize(size_type cItems)
00966 #endif
00967 {
00968 STLSOFT_ASSERT(is_valid_());
00969
00970 resize(cItems, value_type());
00971
00972 STLSOFT_ASSERT(is_valid_());
00973 }
00974
00975 template< ss_typename_param_k T
00976 , ss_typename_param_k A
00977 , ss_size_t SPACE
00978 >
00979 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
00980 inline void pod_vector<T, A, SPACE>::resize(ss_typename_type_k pod_vector<T, A, SPACE>::size_type cItems, ss_typename_type_k pod_vector<T, A, SPACE>::value_type const& value)
00981 #else
00982 inline void pod_vector<T, A, SPACE>::resize(size_type cItems, ss_typename_type_k pod_vector<T, A, SPACE>::value_type const& value)
00983 #endif
00984 {
00985 STLSOFT_ASSERT(is_valid_());
00986
00987 if(m_buffer.resize(cItems))
00988 {
00989 if(m_cItems < cItems)
00990 {
00991 pod_fill_n(begin_() + m_cItems, cItems - m_cItems, value);
00992 }
00993
00994 m_cItems = cItems;
00995 }
00996
00997 STLSOFT_ASSERT(is_valid_());
00998 }
00999
01000 template< ss_typename_param_k T
01001 , ss_typename_param_k A
01002 , ss_size_t SPACE
01003 >
01004 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
01005 inline void pod_vector<T, A, SPACE>::push_back(ss_typename_type_k pod_vector<T, A, SPACE>::value_type const& value)
01006 #else
01007 inline void pod_vector<T, A, SPACE>::push_back(ss_typename_type_k pod_vector<T, A, SPACE>::value_type const& value)
01008 #endif
01009 {
01010 STLSOFT_ASSERT(is_valid_());
01011
01012 insert(end(), value);
01013
01014 STLSOFT_ASSERT(is_valid_());
01015 }
01016
01017 template< ss_typename_param_k T
01018 , ss_typename_param_k A
01019 , ss_size_t SPACE
01020 >
01021 inline void pod_vector<T, A, SPACE>::pop_back()
01022 {
01023 STLSOFT_ASSERT(is_valid_());
01024
01025 STLSOFT_MESSAGE_ASSERT("No elements to pop", size() > 0);
01026
01027 if(0 == --m_cItems)
01028 {
01029 m_buffer.resize(0);
01030 }
01031
01032 STLSOFT_ASSERT(is_valid_());
01033 }
01034
01035 template< ss_typename_param_k T
01036 , ss_typename_param_k A
01037 , ss_size_t SPACE
01038 >
01039 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
01040 inline void pod_vector<T, A, SPACE>::assign(ss_typename_type_k pod_vector<T, A, SPACE>::const_iterator first, ss_typename_type_k pod_vector<T, A, SPACE>::const_iterator last)
01041 #else
01042 inline void pod_vector<T, A, SPACE>::assign(const_iterator first, const_iterator last)
01043 #endif
01044 {
01045 STLSOFT_ASSERT(is_valid_());
01046
01047
01048
01049 class_type temp(first, last);
01050
01051 temp.swap(*this);
01052
01053 STLSOFT_ASSERT(is_valid_());
01054 }
01055
01056 template< ss_typename_param_k T
01057 , ss_typename_param_k A
01058 , ss_size_t SPACE
01059 >
01060 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
01061 inline void pod_vector<T, A, SPACE>::assign(ss_typename_type_k pod_vector<T, A, SPACE>::size_type cItems, ss_typename_type_k pod_vector<T, A, SPACE>::value_type const& value )
01062 #else
01063 inline void pod_vector<T, A, SPACE>::assign(size_type cItems, value_type const& value )
01064 #endif
01065 {
01066 STLSOFT_ASSERT(is_valid_());
01067
01068
01069
01070 class_type temp(cItems, value);
01071
01072 temp.swap(*this);
01073
01074 STLSOFT_ASSERT(is_valid_());
01075 }
01076
01077 template< ss_typename_param_k T
01078 , ss_typename_param_k A
01079 , ss_size_t SPACE
01080 >
01081 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
01082 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::iterator pod_vector<T, A, SPACE>::insert(ss_typename_type_k pod_vector<T, A, SPACE>::iterator it, ss_typename_type_k pod_vector<T, A, SPACE>::value_type const& value )
01083 #else
01084 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::iterator pod_vector<T, A, SPACE>::insert(iterator it, value_type const& value )
01085 #endif
01086 {
01087 STLSOFT_ASSERT(is_valid_());
01088
01089 STLSOFT_ASSERT(!(end() < it));
01090 STLSOFT_ASSERT(!(it < begin()));
01091
01092 size_type index = static_cast<size_type>(it - begin());
01093
01094 insert(it, 1, value);
01095
01096 STLSOFT_ASSERT(is_valid_());
01097
01098 return begin() + index;
01099 }
01100
01101 template< ss_typename_param_k T
01102 , ss_typename_param_k A
01103 , ss_size_t SPACE
01104 >
01105 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
01106 inline void pod_vector<T, A, SPACE>::insert(ss_typename_type_k pod_vector<T, A, SPACE>::iterator it, ss_typename_type_k pod_vector<T, A, SPACE>::size_type cItems, ss_typename_type_k pod_vector<T, A, SPACE>::value_type const& value)
01107 #else
01108 inline void pod_vector<T, A, SPACE>::insert(iterator it, size_type cItems, value_type const& value)
01109 #endif
01110 {
01111 STLSOFT_ASSERT(is_valid_());
01112
01113 STLSOFT_ASSERT(!(end() < it));
01114 STLSOFT_ASSERT(!(it < begin()));
01115
01116 size_type curr_size = size();
01117 size_type index = static_cast<size_type>(it - begin());
01118
01119 if(resize_(size() + cItems))
01120 {
01121 size_type cMove = curr_size - index;
01122
01123
01124 it = begin() + index;
01125
01126
01127 pod_move_n(&it[cItems], &it[0], cMove);
01128
01129
01130 pod_fill_n(begin_() + index, cItems, value);
01131 }
01132
01133 STLSOFT_ASSERT(is_valid_());
01134 }
01135
01136 template< ss_typename_param_k T
01137 , ss_typename_param_k A
01138 , ss_size_t SPACE
01139 >
01140 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
01141 inline void pod_vector<T, A, SPACE>::insert(ss_typename_type_k pod_vector<T, A, SPACE>::iterator it, ss_typename_type_k pod_vector<T, A, SPACE>::const_iterator first, ss_typename_type_k pod_vector<T, A, SPACE>::const_iterator last)
01142 #else
01143 inline void pod_vector<T, A, SPACE>::insert(iterator it, const_iterator first, const_iterator last)
01144 #endif
01145 {
01146 STLSOFT_ASSERT(is_valid_());
01147
01148 STLSOFT_ASSERT(!(end() < it));
01149 STLSOFT_ASSERT(!(it < begin()));
01150
01151 size_type curr_size = size();
01152 size_type index = it - begin();
01153 size_type cItems = last - first;
01154
01155 if(resize_(size() + cItems))
01156 {
01157 size_type cMove = curr_size - index;
01158
01159
01160 it = begin() + index;
01161
01162
01163 pod_move_n(&it[cItems], &it[0], cMove);
01164
01165
01166 pod_copy_n(it, first, cItems);
01167 }
01168
01169 STLSOFT_ASSERT(is_valid_());
01170 }
01171
01172 template< ss_typename_param_k T
01173 , ss_typename_param_k A
01174 , ss_size_t SPACE
01175 >
01176 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
01177 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::iterator pod_vector<T, A, SPACE>::erase(ss_typename_type_k pod_vector<T, A, SPACE>::iterator it)
01178 #else
01179 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::iterator pod_vector<T, A, SPACE>::erase(iterator it)
01180 #endif
01181 {
01182 STLSOFT_ASSERT(is_valid_());
01183
01184 STLSOFT_ASSERT(it < end());
01185 STLSOFT_ASSERT(!(it < begin()));
01186
01187 size_type index = it - begin();
01188 size_type cMove = size() - (index + 1);
01189
01190 pod_move_n(&it[0], &it[1], cMove);
01191
01192 if(0 == --m_cItems)
01193 {
01194 m_buffer.resize(0);
01195
01196 it = begin();
01197 }
01198
01199 STLSOFT_ASSERT(is_valid_());
01200
01201 return it;
01202 }
01203
01204 template< ss_typename_param_k T
01205 , ss_typename_param_k A
01206 , ss_size_t SPACE
01207 >
01208 #if defined(STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED)
01209 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::iterator pod_vector<T, A, SPACE>::erase(ss_typename_type_k pod_vector<T, A, SPACE>::iterator first, ss_typename_type_k pod_vector<T, A, SPACE>::iterator last)
01210 #else
01211 inline ss_typename_type_ret_k pod_vector<T, A, SPACE>::iterator pod_vector<T, A, SPACE>::erase(iterator first, iterator last)
01212 #endif
01213 {
01214 STLSOFT_ASSERT(is_valid_());
01215
01216 STLSOFT_ASSERT(first < end());
01217 STLSOFT_ASSERT(!(first < begin()));
01218 STLSOFT_ASSERT(!(end() < last));
01219 STLSOFT_ASSERT(!(last < begin()));
01220
01221 size_type curr_size = size();
01222 size_type index_first = first - begin();
01223 size_type index_last = last - begin();
01224 size_type cItems = last - first;
01225 size_type cMove = curr_size - index_last;
01226
01227
01228 pod_move_n(&first[0], &last[0], cMove);
01229
01230 resize(curr_size - cItems);
01231
01232 STLSOFT_ASSERT(is_valid_());
01233
01234 return begin() + index_first;
01235 }
01236
01237 #endif
01238
01239
01240
01241 #ifndef _STLSOFT_NO_NAMESPACE
01242 }
01243 #endif
01244
01245
01246
01247
01248 #if defined(STLSOFT_CF_std_NAMESPACE)
01249 # if ( ( defined(STLSOFT_COMPILER_IS_INTEL) && \
01250 defined(_MSC_VER))) && \
01251 _MSC_VER < 1310
01252 namespace std
01253 {
01254 template< ss_typename_param_k T
01255 , ss_typename_param_k A
01256 , stlsoft_ns_qual(ss_size_t) SPACE
01257 >
01258 inline void swap(stlsoft_ns_qual(pod_vector)<T, A, SPACE>& lhs, stlsoft_ns_qual(pod_vector)<T, A, SPACE>& rhs)
01259 {
01260 lhs.swap(rhs);
01261 }
01262 }
01263 # endif
01264 #endif
01265
01266
01267
01268 #endif
01269
01270