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
00047 #ifndef ATLSTL_INCL_ATLSTL_STRING_HPP_CCOMBSTR_VENEER
00048 #define ATLSTL_INCL_ATLSTL_STRING_HPP_CCOMBSTR_VENEER
00049
00050 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00051 # define ATLSTL_VER_ATLSTL_STRING_HPP_CCOMBSTR_VENEER_MAJOR 5
00052 # define ATLSTL_VER_ATLSTL_STRING_HPP_CCOMBSTR_VENEER_MINOR 3
00053 # define ATLSTL_VER_ATLSTL_STRING_HPP_CCOMBSTR_VENEER_REVISION 1
00054 # define ATLSTL_VER_ATLSTL_STRING_HPP_CCOMBSTR_VENEER_EDIT 76
00055 #endif
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071 #ifndef ATLSTL_INCL_ATLSTL_HPP_ATLSTL
00072 # include <atlstl/atlstl.hpp>
00073 #endif
00074 #ifndef STLSOFT_INCL_STLSOFT_UTIL_STD_HPP_ITERATOR_HELPER
00075 # include <stlsoft/util/std/iterator_helper.hpp>
00076 #endif
00077 #ifndef STLSOFT_INCL_STLSOFT_UTIL_HPP_CONSTRAINTS
00078 # include <stlsoft/util/constraints.hpp>
00079 #endif
00080 #ifndef STLSOFT_INCL_STLSOFT_MEMORY_HPP_AUTO_BUFFER
00081 # include <stlsoft/memory/auto_buffer.hpp>
00082 #endif
00083 #if defined(STLSOFT_COMPILER_IS_DMC)
00084 # ifndef STLSOFT_INCL_STLSOFT_CONVERSION_HPP_SAP_CAST
00085 # include <stlsoft/conversion/sap_cast.hpp>
00086 # endif
00087 #endif
00088 #ifndef STLSOFT_INCL_STLSOFT_STRING_HPP_STRING_TRAITS_FWD
00089 # include <stlsoft/string/string_traits_fwd.hpp>
00090 #endif
00091 #ifndef STLSOFT_INCL_STLSOFT_UTIL_STD_HPP_ITERATOR_HELPER
00092 # include <stlsoft/util/std/iterator_helper.hpp>
00093 #endif
00094 #ifndef STLSOFT_INCL_STLSOFT_UTIL_HPP_STD_SWAP
00095 # include <stlsoft/util/std_swap.hpp>
00096 #endif
00097
00098 #ifndef STLSOFT_INCL_H_WCHAR
00099 # define STLSOFT_INCL_H_WCHAR
00100 # include <wchar.h>
00101 #endif
00102
00103
00104
00105
00106
00107 #ifndef _ATLSTL_NO_NAMESPACE
00108 # if defined(_STLSOFT_NO_NAMESPACE) || \
00109 defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
00110
00111 namespace atlstl
00112 {
00113 # else
00114
00115
00116 namespace stlsoft
00117 {
00118
00119 namespace atlstl_project
00120 {
00121
00122 # endif
00123 #endif
00124
00125
00126
00127
00128
00137
00138 class ccombstr_veneer
00139 #ifdef _ATLSTL_CCOMBSTR_VENEER_INHERIT_AS_PUBLIC
00140 : public CComBSTR
00141 #else
00142 # if defined(STLSOFT_COMPILER_IS_DMC)
00143 : protected CComBSTR
00144 # else
00145 : private CComBSTR
00146 # endif
00147 #endif
00148 {
00149 private:
00150 typedef CComBSTR parent_class_type;
00151 typedef ccombstr_veneer class_type;
00152 public:
00154 typedef OLECHAR value_type;
00156 typedef LPOLESTR iterator;
00158 typedef LPCOLESTR const_iterator;
00160 typedef LPOLESTR pointer;
00162 typedef LPCOLESTR const_pointer;
00164 typedef OLECHAR& reference;
00166 typedef OLECHAR const& const_reference;
00168 typedef as_size_t size_type;
00170 typedef as_ptrdiff_t difference_type;
00171 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
00172
00173
00174
00175
00176
00177
00178
00179 typedef stlsoft_ns_qual(const_reverse_iterator_base)< const_iterator
00180 , value_type const
00181 , const_reference
00182 , const_pointer
00183 , difference_type
00184 > const_reverse_iterator;
00185 #endif
00186
00187
00188 public:
00190 ccombstr_veneer();
00192 ccombstr_veneer(class_type const& rhs);
00194 ss_explicit_k ccombstr_veneer(CComBSTR const& rhs);
00196 ss_explicit_k ccombstr_veneer(LPCSTR s);
00198 ss_explicit_k ccombstr_veneer(LPCWSTR s);
00200 ccombstr_veneer(LPCOLESTR from, LPCOLESTR to);
00202 ccombstr_veneer(size_type length, LPCOLESTR from);
00204 ccombstr_veneer(as_size_t cch, OLECHAR ch);
00205
00207 class_type const& operator =(class_type const& rhs);
00209 class_type const& operator =(CComBSTR const& rhs);
00211 class_type const& operator =(LPCSTR s);
00213 class_type const& operator =(LPCWSTR s);
00214
00215
00216 public:
00220 const_iterator begin() const;
00224 const_iterator end() const;
00225
00226 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
00230 const_reverse_iterator rbegin() const;
00234 const_reverse_iterator rend() const;
00235 #endif
00236
00237
00238 public:
00239 reference operator [](size_type index);
00240 const_reference operator [](size_type index) const;
00241
00242
00243 public:
00244 void swap(class_type& rhs);
00245
00246
00247 public:
00249 CComBSTR &get_base_type();
00251 CComBSTR const &get_base_type() const;
00253 size_type length() const;
00255 size_type size() const;
00257 as_bool_t empty() const;
00259 const_pointer c_str() const;
00261 const_pointer data() const;
00262 };
00263
00264
00265
00266
00267
00268 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00269
00270
00271
00272
00273
00274
00275
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285 inline int atlstl_safe_wcscmp(LPCOLESTR s1, LPCOLESTR s2)
00286 {
00287 return (NULL == s1)
00288 ? (NULL == s2)
00289 ? 0
00290 : 1
00291 : (NULL == s2)
00292 ? -1
00293 : wcscmp(s1, s2);
00294 }
00295
00296 inline int atlstl_safe_wcscmp(LPCOLESTR s1, LPCSTR s2)
00297 {
00298 USES_CONVERSION;
00299
00300 return atlstl_safe_wcscmp(s1, (NULL == s2) ? L"" : A2CW(s2));
00301 }
00302
00303 inline int atlstl_safe_wcscmp(LPCSTR s1, LPCOLESTR s2)
00304 {
00305 USES_CONVERSION;
00306
00307 return atlstl_safe_wcscmp((NULL == s1) ? L"" : A2CW(s1), s2);
00308 }
00309
00310 #if 0
00311
00312
00313 bool CComBSTR::operator==(CComBSTR const& bstrSrc) const throw()
00314 bool CComBSTR::operator==(LPCOLESTR pszSrc) const
00315 bool CComBSTR::operator==(LPOLESTR pszSrc) const
00316 bool CComBSTR::operator==(int nNull) const throw()
00317 bool CComBSTR::operator==(LPCSTR pszSrc) const
00318
00319
00320 bool CComBSTR::operator==(CComBSTR const& bstrSrc) const throw()
00321 bool CComBSTR::operator==(LPCOLESTR pszSrc) const
00322 bool CComBSTR::operator==(LPOLESTR pszSrc) const
00323 bool CComBSTR::operator==(int nNull) const throw()
00324 bool CComBSTR::operator==(LPCSTR pszSrc) const
00325
00326
00327 bool CComBSTR::operator==(CComBSTR const& bstrSrc) const throw()
00328 bool CComBSTR::operator==(LPCOLESTR pszSrc) const
00329 bool CComBSTR::operator==(int nNull) const throw()
00330 bool CComBSTR::operator==(LPCSTR pszSrc) const
00331
00332
00333 bool CComBSTR::operator==(BSTR bstrSrc) const
00334 bool CComBSTR::operator==(LPCSTR pszSrc) const
00335
00336
00337
00338 #endif
00339
00340
00341 #endif
00342
00343
00344
00345
00346
00347 inline as_bool_t operator ==(ccombstr_veneer const& lhs, ccombstr_veneer const& rhs)
00348 {
00349 CComBSTR const& lhs_ = lhs.get_base_type();
00350 CComBSTR const& rhs_ = rhs.get_base_type();
00351
00352 #if _ATL_VER >= 0x0700
00353 return lhs_ == rhs_;
00354 #else // ? _ATL_VER
00355 return 0 == atlstl_safe_wcscmp(lhs_, rhs_);
00356 #endif // _ATL_VER
00357 }
00358
00359 #if !defined(STLSOFT_COMPILER_IS_MSVC) || \
00360 _MSC_VER >= 1200
00361
00362 inline as_bool_t operator ==(LPCSTR lhs, ccombstr_veneer const& rhs)
00363 {
00364 CComBSTR const& rhs_ = rhs.get_base_type();
00365
00366 #if _ATL_VER >= 0x0300
00367 return rhs_ == lhs;
00368 #else
00369 return 0 == atlstl_safe_wcscmp(lhs, rhs_);
00370 #endif
00371 }
00372
00373 inline as_bool_t operator ==(ccombstr_veneer const& lhs, LPCSTR rhs)
00374 {
00375 CComBSTR const& lhs_ = lhs.get_base_type();
00376
00377 #if _ATL_VER >= 0x0300
00378 return lhs_ == rhs;
00379 #else
00380 return 0 == atlstl_safe_wcscmp(lhs_, rhs);
00381 #endif
00382 }
00383
00384 #endif
00385
00386 inline as_bool_t operator ==(LPCWSTR lhs, ccombstr_veneer const& rhs)
00387 {
00388 CComBSTR const& rhs_ = rhs.get_base_type();
00389
00390 #if _ATL_VER >= 0x0700
00391 return rhs_ == lhs;
00392 #else // ? _ATL_VER
00393 return 0 == atlstl_safe_wcscmp(lhs, rhs_);
00394 #endif // _ATL_VER
00395 }
00396
00397 inline as_bool_t operator ==(ccombstr_veneer const& lhs, LPCWSTR rhs)
00398 {
00399 CComBSTR const& lhs_ = lhs.get_base_type();
00400
00401 #if _ATL_VER >= 0x0700
00402 return lhs_ == rhs;
00403 #else // ? _ATL_VER
00404 return 0 == atlstl_safe_wcscmp(lhs_, rhs);
00405 #endif // _ATL_VER
00406 }
00407
00408 inline as_bool_t operator !=(ccombstr_veneer const& lhs, ccombstr_veneer const& rhs)
00409 {
00410 return !operator ==(lhs, rhs);
00411 }
00412
00413 #if !defined(STLSOFT_COMPILER_IS_MSVC) || \
00414 _MSC_VER >= 1200
00415
00416 inline as_bool_t operator !=(LPCSTR lhs, ccombstr_veneer const& rhs)
00417 {
00418 return !operator ==(lhs, rhs);
00419 }
00420
00421 inline as_bool_t operator !=(ccombstr_veneer const& lhs, LPCSTR rhs)
00422 {
00423 return !operator ==(lhs, rhs);
00424 }
00425
00426 #endif
00427
00428 inline as_bool_t operator !=(LPCWSTR lhs, ccombstr_veneer const& rhs)
00429 {
00430 return !operator ==(lhs, rhs);
00431 }
00432
00433 inline as_bool_t operator !=(ccombstr_veneer const& lhs, LPCWSTR rhs)
00434 {
00435 return !operator ==(lhs, rhs);
00436 }
00437
00438
00439
00440
00441
00442 inline void swap(ccombstr_veneer& lhs, ccombstr_veneer& rhs)
00443 {
00444 lhs.swap(rhs);
00445 }
00446
00447
00448
00449
00450
00455 inline LPCOLESTR c_str_data(atlstl_ns_qual(ccombstr_veneer) const& str)
00456 {
00457 return str.data();
00458 }
00459
00460 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00461 inline LPCOLESTR c_str_data_w(atlstl_ns_qual(ccombstr_veneer) const& str) { return c_str_data(str); }
00462 #endif
00463
00464
00469 inline as_size_t c_str_len(atlstl_ns_qual(ccombstr_veneer) const& str)
00470 {
00471 return str.length();
00472 }
00473
00474 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00475 inline as_size_t c_str_len_w(atlstl_ns_qual(ccombstr_veneer) const& str) { return c_str_len(str); }
00476 #endif
00477
00478
00483 inline LPCOLESTR c_str_ptr(atlstl_ns_qual(ccombstr_veneer) const& str)
00484 {
00485 return str.c_str();
00486 }
00487
00488 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00489 inline LPCOLESTR c_str_ptr_w(atlstl_ns_qual(ccombstr_veneer) const& str) { return c_str_ptr(str); }
00490 #endif
00491
00492
00497 inline LPCOLESTR c_str_ptr_null(atlstl_ns_qual(ccombstr_veneer) const& str)
00498 {
00499 return !str.empty() ? str.c_str() : NULL;
00500 }
00501
00502 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00503 inline LPCOLESTR c_str_ptr_null_w(atlstl_ns_qual(ccombstr_veneer) const& str) { return c_str_ptr_null(str); }
00504 #endif
00505
00506
00507
00508
00513 template<ss_typename_param_k S>
00514 inline S& operator <<(S& s, atlstl_ns_qual(ccombstr_veneer) const& str)
00515 {
00516 s << str.c_str();
00517
00518 return s;
00519 }
00520
00521
00522
00523
00524
00525 #ifdef STLSOFT_UNITTEST
00526 # include "./unittest/ccombstr_veneer_unittest_.h"
00527 #endif
00528
00529
00530
00531
00532
00533 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00534
00535 inline ccombstr_veneer::ccombstr_veneer()
00536 : parent_class_type()
00537 {
00538 stlsoft_constraint_must_be_same_size(CComBSTR, class_type);
00539 }
00540
00541 inline ccombstr_veneer::ccombstr_veneer(class_type const& rhs)
00542 : parent_class_type(rhs)
00543 {
00544 stlsoft_constraint_must_be_same_size(CComBSTR, class_type);
00545 }
00546
00547 inline ccombstr_veneer::ccombstr_veneer(CComBSTR const& rhs)
00548 : parent_class_type(rhs)
00549 {
00550 stlsoft_constraint_must_be_same_size(CComBSTR, class_type);
00551 }
00552
00553 inline ccombstr_veneer::ccombstr_veneer(LPCSTR s)
00554
00555
00556
00557 #if _ATL_VER >= 0x0700
00558 : parent_class_type(s)
00559 #endif
00560 {
00561 #if _ATL_VER < 0x0700
00562 USES_CONVERSION;
00563 *this = A2COLE(s);
00564 #endif
00565
00566 ATLSTL_ASSERT(s == NULL || length() == strlen(s));
00567
00568 stlsoft_constraint_must_be_same_size(CComBSTR, class_type);
00569 }
00570
00571 inline ccombstr_veneer::ccombstr_veneer(LPCWSTR s)
00572 #if _ATL_VER >= 0x0300
00573 : parent_class_type(s)
00574 #endif
00575 {
00576 #if _ATL_VER < 0x0300
00577 USES_CONVERSION;
00578 *this = s;
00579 #endif
00580
00581 ATLSTL_ASSERT(s == NULL || length() == wcslen(s));
00582
00583 stlsoft_constraint_must_be_same_size(CComBSTR, class_type);
00584 }
00585
00586 inline ccombstr_veneer::ccombstr_veneer(LPCOLESTR from, LPCOLESTR to)
00587 : parent_class_type(static_cast<int>(to - from), from)
00588 {
00589 stlsoft_constraint_must_be_same_size(CComBSTR, class_type);
00590 }
00591
00592 inline void ccombstr_veneer::swap(ccombstr_veneer::class_type& rhs)
00593 {
00594 std_swap(m_str, rhs.m_str);
00595 }
00596
00597 inline ccombstr_veneer::ccombstr_veneer(ccombstr_veneer::size_type length, LPCOLESTR from)
00598 : parent_class_type(static_cast<int>(length), from)
00599 {
00600 stlsoft_constraint_must_be_same_size(CComBSTR, class_type);
00601 }
00602
00603 inline ccombstr_veneer::ccombstr_veneer(as_size_t cch, OLECHAR ch)
00604 {
00605 stlsoft_constraint_must_be_same_size(CComBSTR, class_type);
00606
00607 typedef stlsoft_ns_qual(auto_buffer)<OLECHAR> buffer_t;
00608
00609 buffer_t buffer(cch);
00610
00611 _wcsnset(&buffer[0], ch, cch);
00612
00613 class_type(cch, buffer.data()).swap(*this);
00614 }
00615
00616 inline ccombstr_veneer::class_type const& ccombstr_veneer::operator =(ccombstr_veneer::class_type const& rhs)
00617 {
00618 parent_class_type::operator =(rhs);
00619
00620 return *this;
00621 }
00622
00623 inline ccombstr_veneer::class_type const& ccombstr_veneer::operator =(CComBSTR const& rhs)
00624 {
00625 parent_class_type::operator =(rhs);
00626
00627 return *this;
00628 }
00629
00630 inline ccombstr_veneer::class_type const& ccombstr_veneer::operator =(LPCSTR s)
00631 {
00632
00633
00634
00635 #if _ATL_VER >= 0x0700
00636 parent_class_type::operator =(s);
00637 #else
00638 USES_CONVERSION;
00639 *this = A2COLE(s);
00640 #endif
00641
00642 return *this;
00643 }
00644
00645 inline ccombstr_veneer::class_type const& ccombstr_veneer::operator =(LPCWSTR s)
00646 {
00647 parent_class_type::operator =(s);
00648
00649 return *this;
00650 }
00651
00652 inline ccombstr_veneer::const_iterator ccombstr_veneer::begin() const
00653 {
00654 return *this;
00655 }
00656
00657 inline ccombstr_veneer::const_iterator ccombstr_veneer::end() const
00658 {
00659 return begin() + Length();
00660 }
00661
00662 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
00663 inline ccombstr_veneer::const_reverse_iterator ccombstr_veneer::rbegin() const
00664 {
00665 return const_reverse_iterator(end());
00666 }
00667
00668 inline ccombstr_veneer::const_reverse_iterator ccombstr_veneer::rend() const
00669 {
00670 return const_reverse_iterator(begin());
00671 }
00672 #endif
00673
00674 inline ccombstr_veneer::reference ccombstr_veneer::operator [](ccombstr_veneer::size_type index)
00675 {
00676 ATLSTL_MESSAGE_ASSERT("Index out of range", index < length());
00677
00678 return const_cast<reference>(data()[index]);
00679 }
00680
00681 inline ccombstr_veneer::const_reference ccombstr_veneer::operator [](ccombstr_veneer::size_type index) const
00682 {
00683 ATLSTL_MESSAGE_ASSERT("Index out of range", index < length());
00684
00685 return data()[index];
00686 }
00687
00688 inline CComBSTR &ccombstr_veneer::get_base_type()
00689 {
00690 #if defined(STLSOFT_COMPILER_IS_DMC)
00691 CComBSTR *this_ = stlsoft_ns_qual(sap_cast)<CComBSTR*>(this);
00692 #else
00693 CComBSTR *this_ = this;
00694 #endif
00695
00696 return *this_;
00697 }
00698
00699 inline CComBSTR const& ccombstr_veneer::get_base_type() const
00700 {
00701 #if defined(STLSOFT_COMPILER_IS_DMC)
00702 CComBSTR const *this_ = stlsoft_ns_qual(sap_cast)<CComBSTR const*>(this);
00703 #else
00704 CComBSTR const *this_ = this;
00705 #endif
00706
00707 return *this_;
00708 }
00709
00710 inline ccombstr_veneer::size_type ccombstr_veneer::length() const
00711 {
00712 return Length();
00713 }
00714
00715 inline ccombstr_veneer::size_type ccombstr_veneer::size() const
00716 {
00717 return length();
00718 }
00719
00720 inline as_bool_t ccombstr_veneer::empty() const
00721 {
00722 return length() == 0;
00723 }
00724
00725 inline ccombstr_veneer::const_pointer ccombstr_veneer::c_str() const
00726 {
00727 return empty() ? L"" : static_cast<const_pointer>(*this);
00728 }
00729
00730 inline ccombstr_veneer::const_pointer ccombstr_veneer::data() const
00731 {
00732 return empty() ? L"" : static_cast<const_pointer>(*this);
00733 }
00734
00735 #endif
00736
00737
00738
00739 #ifndef _ATLSTL_NO_NAMESPACE
00740 # if defined(_STLSOFT_NO_NAMESPACE) || \
00741 defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
00742 }
00743 # else
00744 }
00745 }
00746 # endif
00747 #endif
00748
00749 #if defined(STLSOFT_CF_std_NAMESPACE)
00750 namespace stlsoft
00751 {
00752 inline void swap(atlstl_ns_qual(ccombstr_veneer)& lhs, atlstl_ns_qual(ccombstr_veneer)& rhs)
00753 {
00754 lhs.swap(rhs);
00755 }
00756 }
00757 #endif
00758
00759
00760
00761
00762
00763
00764
00765
00766
00767 #ifndef _ATLSTL_NO_NAMESPACE
00768 # if !defined(_STLSOFT_NO_NAMESPACE) && \
00769 !defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
00770 namespace stlsoft
00771 {
00772 # else
00773
00774 # endif
00775
00776 using ::atlstl::c_str_data;
00777 using ::atlstl::c_str_data_w;
00778
00779 using ::atlstl::c_str_len;
00780 using ::atlstl::c_str_len_w;
00781
00782 using ::atlstl::c_str_ptr;
00783 using ::atlstl::c_str_ptr_w;
00784
00785 using ::atlstl::c_str_ptr_null;
00786 using ::atlstl::c_str_ptr_null_w;
00787
00788
00789
00790
00791
00794 STLSOFT_TEMPLATE_SPECIALISATION
00795 struct string_traits< ::atlstl::ccombstr_veneer>
00796 {
00797 typedef ::atlstl::ccombstr_veneer value_type;
00798 typedef ::atlstl::ccombstr_veneer::value_type char_type;
00799 typedef value_type::size_type size_type;
00800 typedef char_type const const_char_type;
00801 typedef value_type string_type;
00802 typedef string_type::pointer pointer;
00803 typedef string_type::const_pointer const_pointer;
00804 typedef string_type::iterator iterator;
00805 typedef string_type::const_iterator const_iterator;
00806 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
00807
00808 typedef string_type::const_reverse_iterator const_reverse_iterator;
00809 #endif
00810 enum
00811 {
00812 is_pointer = false
00813 , is_pointer_to_const = false
00814 , char_type_size = sizeof(char_type)
00815 };
00816
00817 static string_type empty_string()
00818 {
00819 return string_type();
00820 }
00821 static string_type construct(string_type const& src, size_type pos, size_type len)
00822 {
00823 return string_type(len, src.data() + pos);
00824 }
00825 # ifdef STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT
00826 template <ss_typename_param_k I>
00827 static string_type &assign_inplace(string_type &str, I first, I last)
00828 # else
00829 static string_type &assign_inplace(string_type &str, const_iterator first, const_iterator last)
00830 # endif
00831 {
00832
00833 return (str = string_type(last - first, first), str);
00834 }
00835 };
00836
00837
00838 # if !defined(_STLSOFT_NO_NAMESPACE) && \
00839 !defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
00840 }
00841 # else
00842
00843 # endif
00844 #endif
00845
00846
00847
00848 #endif
00849
00850