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
00051 #ifndef STLSOFT_INCL_STLSOFT_STRING_HPP_SPECIAL_STRING_INSTANCE
00052 #define STLSOFT_INCL_STLSOFT_STRING_HPP_SPECIAL_STRING_INSTANCE
00053
00054 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00055 # define STLSOFT_VER_STLSOFT_STRING_HPP_SPECIAL_STRING_INSTANCE_MAJOR 1
00056 # define STLSOFT_VER_STLSOFT_STRING_HPP_SPECIAL_STRING_INSTANCE_MINOR 2
00057 # define STLSOFT_VER_STLSOFT_STRING_HPP_SPECIAL_STRING_INSTANCE_REVISION 5
00058 # define STLSOFT_VER_STLSOFT_STRING_HPP_SPECIAL_STRING_INSTANCE_EDIT 19
00059 #endif
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080 #ifndef STLSOFT_INCL_STLSOFT_H_STLSOFT
00081 # include <stlsoft/stlsoft.h>
00082 #endif
00083 #ifndef STLSOFT_INCL_STLSOFT_MEMORY_HPP_AUTO_BUFFER
00084 # include <stlsoft/memory/auto_buffer.hpp>
00085 #endif
00086 #ifndef STLSOFT_INCL_STLSOFT_META_HPP_IS_SAME_TYPE
00087 # include <stlsoft/meta/is_same_type.hpp>
00088 #endif
00089 #ifndef STLSOFT_INCL_STLSOFT_META_HPP_SELECT_FIRST_TYPE_IF
00090 # include <stlsoft/meta/select_first_type_if.hpp>
00091 #endif
00092 #ifndef STLSOFT_INCL_STLSOFT_SYNCH_HPP_LOCK_SCOPE
00093 # include <stlsoft/synch/lock_scope.hpp>
00094 #endif
00095
00096
00097
00098
00099
00100 #ifndef _STLSOFT_NO_NAMESPACE
00101 namespace stlsoft
00102 {
00103 #endif
00104
00105
00106
00107
00108
00109 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00110
00111 template< ss_typename_param_k C
00112 , ss_size_t N
00113 , ss_typename_param_k A
00114 , ss_typename_param_k A0
00115 >
00116 struct ssi_buffer
00117 {
00120 public:
00121 typedef C char_type;
00122 typedef A allocator_type;
00123 typedef ss_size_t size_type;
00124 typedef A0 argument_0_type;
00125 #if defined(STLSOFT_COMPILER_IS_BORLAND)
00126 typedef stlsoft::auto_buffer<char_type, 128, allocator_type> buffer_type;
00127 #else
00128 typedef stlsoft::auto_buffer<char_type, N, allocator_type> buffer_type;
00129 #endif
00131
00134 public:
00135 ssi_buffer()
00136 : m_len(0)
00137 , m_buffer(0)
00138 {}
00139
00140 void init(size_type (*pfn)(char_type*, size_type))
00141 {
00142 size_type cch = pfn(NULL, 0);
00143
00144 if(m_buffer.resize(1 + cch))
00145 {
00146 for(;;)
00147 {
00148 cch = pfn(&m_buffer[0], m_buffer.size());
00149
00150 if(cch < m_buffer.size())
00151 {
00152 m_len = cch;
00153 break;
00154 }
00155 else
00156 {
00157 if(!m_buffer.resize(2 * m_buffer.size()))
00158 {
00159 m_buffer.resize(0);
00160 break;
00161 }
00162 }
00163 }
00164 }
00165
00166 m_buffer[m_len] = '\0';
00167 }
00168
00169 void init(argument_0_type arg0, size_type (*pfn)(argument_0_type, char_type*, size_type))
00170 {
00171 size_type cch = pfn(arg0, NULL, 0);
00172
00173 if(m_buffer.resize(1 + cch))
00174 {
00175 for(;;)
00176 {
00177 cch = pfn(arg0, &m_buffer[0], m_buffer.size());
00178
00179 if(cch < m_buffer.size())
00180 {
00181 m_len = cch;
00182 break;
00183 }
00184 else
00185 {
00186 if(!m_buffer.resize(2 * m_buffer.size()))
00187 {
00188 m_buffer.resize(0);
00189 break;
00190 }
00191 }
00192 }
00193 }
00194
00195 m_buffer[m_len] = '\0';
00196 }
00198
00201 public:
00202 char_type const* data() const
00203 {
00204 return m_buffer.data();
00205 }
00206 size_type length() const
00207 {
00208 return m_len;
00209 }
00211
00214 private:
00215 size_type m_len;
00216 buffer_type m_buffer;
00218 };
00219
00220 template< ss_typename_param_k C
00221 , ss_size_t N
00222 , ss_typename_param_k A
00223 , ss_typename_param_k A0
00224 >
00225 struct ssi_buffer_non_static
00226 : public ssi_buffer<C, N, A, A0>
00227 {
00230 public:
00231 typedef ssi_buffer<C, N, A, A0> ssi_buffer_type;
00232 typedef ssi_buffer<C, N, A, A0> parent_class_type;
00233 typedef ssi_buffer_non_static<C, N, A, A0> class_type;
00234
00235 typedef ss_typename_type_k ssi_buffer_type::char_type char_type;
00236 typedef ss_typename_type_k ssi_buffer_type::size_type size_type;
00238
00241 public:
00242 ssi_buffer_non_static(size_type (*pfn)(char_type*, size_type))
00243 {
00244 parent_class_type::init(pfn);
00245 }
00246 ssi_buffer_non_static(A0 a0, size_type (*pfn)(A0, char_type*, size_type))
00247 {
00248 parent_class_type::init(a0, pfn);
00249 }
00251
00254 public:
00255 char_type const* data() const
00256 {
00257 return parent_class_type::data();
00258 }
00259 size_type length() const
00260 {
00261 return parent_class_type::length();
00262 }
00264
00267 private:
00268 ssi_buffer_non_static(class_type const&);
00269 class_type& operator =(class_type const&);
00271 };
00272
00273 template< ss_typename_param_k C
00274 , ss_size_t N
00275 , ss_typename_param_k A
00276 , ss_typename_param_k A0
00277 , ss_typename_param_k P
00278 >
00279 struct ssi_buffer_static
00280 {
00283 public:
00284 typedef ssi_buffer<C, N, A, A0> ssi_buffer_type;
00285 typedef ssi_buffer_static<C, N, A, A0, P> class_type;
00286
00287 typedef ss_typename_type_k ssi_buffer_type::char_type char_type;
00288 typedef ss_typename_type_k ssi_buffer_type::size_type size_type;
00289 private:
00290 typedef P policy_type;
00291 typedef ss_typename_type_k policy_type::spin_mutex_type spin_mutex_type;
00293
00296 public:
00297 ssi_buffer_static(size_type (*pfn)(char_type*, size_type))
00298 : m_buffer(get_buffer(pfn))
00299 {}
00300 ssi_buffer_static(A0 a0, size_type (*pfn)(A0, char_type*, size_type))
00301 : m_buffer(a0, get_buffer(a0, pfn))
00302 {}
00304
00307 public:
00308 char_type const* data() const
00309 {
00310 return m_buffer.data();
00311 }
00312 size_type length() const
00313 {
00314 return m_buffer.length();
00315 }
00317
00320 private:
00321 static ssi_buffer_type &get_buffer(size_type (*pfn)(char_type*, size_type))
00322 {
00323 static ss_sint32_t s_count = 0;
00324 static bool s_bInit = false;
00325 spin_mutex_type mx(&s_count);
00326 stlsoft::lock_scope<spin_mutex_type> lock(mx);
00327
00328 static ssi_buffer_type s_buffer;
00329
00330 if(!s_bInit)
00331 {
00332 s_buffer.init(pfn);
00333
00334 s_bInit = true;
00335 }
00336
00337 return s_buffer;
00338 }
00339 static ssi_buffer_type &get_buffer(A0 a0, size_type (*pfn)(A0, char_type*, size_type))
00340 {
00341 static ss_sint32_t s_count = 0;
00342 static bool s_bInit = false;
00343 spin_mutex_type mx(&s_count);
00344 stlsoft::lock_scope<spin_mutex_type> lock(mx);
00345
00346 static ssi_buffer_type s_buffer;
00347
00348 if(!s_bInit)
00349 {
00350 s_buffer.init(a0, pfn);
00351
00352 s_bInit = true;
00353 }
00354
00355 return s_buffer;
00356 }
00358
00361 private:
00362 ssi_buffer_type &m_buffer;
00364
00367 private:
00368 ssi_buffer_static(class_type const&);
00369 class_type& operator =(class_type const&);
00371 };
00372
00373 #endif
00374
00375
00393 template <ss_typename_param_k P>
00394 class special_string_instance_0
00395 {
00398 public:
00400 typedef P policy_type;
00402 typedef special_string_instance_0<P> class_type;
00404 typedef ss_typename_type_k policy_type::char_type char_type;
00406 typedef ss_typename_type_k policy_type::size_type size_type;
00407
00412 private:
00413 enum { charTypeIsAnsi = is_same_type<ss_char_a_t, char_type>::value };
00414 public:
00415 typedef ss_typename_type_k select_first_type_if<
00416 ss_char_a_t const*
00417 , void
00418 , charTypeIsAnsi
00419 >::type cstring_a_type;
00424 private:
00425 enum { charTypeIsWide = is_same_type<ss_char_w_t, char_type>::value };
00426 public:
00427 typedef ss_typename_type_k select_first_type_if<
00428 ss_char_w_t const*
00429 , void
00430 , charTypeIsWide
00431 >::type cstring_w_type;
00432 private:
00433 typedef ss_typename_type_k policy_type::pfn_type pfn_type;
00434 private:
00435
00436
00437
00438 typedef ss_typename_type_k policy_type::allocator_type putative_allocator_type;
00439 enum
00440 {
00441 policy_has_allocator_type = (0 != size_of<putative_allocator_type>::value)
00442 };
00443 typedef ss_typename_type_k allocator_selector<char_type>::allocator_type backup_allocator_type;
00444 public:
00446 typedef ss_typename_type_k select_first_type_if<
00447 putative_allocator_type
00448 , backup_allocator_type
00449 , policy_has_allocator_type
00450 >::type allocator_type;
00451 private:
00452 enum { allowImplicitConversion = policy_type::allowImplicitConversion };
00453 public:
00455 typedef ss_typename_type_k select_first_type_if<
00456 char_type const*
00457 , void
00458 , allowImplicitConversion
00459 >::type implicit_conversion_type;
00460 private:
00461
00462
00463
00464
00465
00466 enum
00467 {
00468 policy_indicates_shared_state = (0 != policy_type::sharedState)
00469 };
00470
00471 struct null_argument
00472 {};
00473
00474 enum { internalBufferSize = policy_type::internalBufferSize };
00475 typedef ssi_buffer_static<
00476 char_type
00477 , internalBufferSize
00478 , allocator_type
00479 , null_argument
00480 , policy_type
00481 > ssi_buffer_static_type;
00482 typedef ssi_buffer_non_static<
00483 char_type
00484 , internalBufferSize
00485 , allocator_type
00486 , null_argument
00487 > ssi_buffer_non_static_type;
00488
00489 typedef ss_typename_type_k select_first_type_if<
00490 ssi_buffer_static_type
00491 , ssi_buffer_non_static_type
00492 , policy_indicates_shared_state
00493 >::type buffer_type;
00495
00498 public:
00499 special_string_instance_0()
00500 : m_buffer(policy_type::get_fn())
00501 {}
00503
00506 public:
00507 size_type length() const
00508 {
00509 return m_buffer.length();
00510 }
00511 size_type size() const
00512 {
00513 return length();
00514 }
00515
00516 char_type const* data() const
00517 {
00518 return m_buffer.data();
00519 }
00520 char_type const* c_str() const
00521 {
00522 return data();
00523 }
00524
00525 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00526 cstring_a_type c_str_a() const
00527 {
00528 return c_str();
00529 }
00530 cstring_w_type c_str_w() const
00531 {
00532 return c_str();
00533 }
00534 #endif
00536
00539 public:
00540 #if !defined(STLSOFT_COMPILER_IS_BORLAND)
00541 operator implicit_conversion_type () const
00542 {
00543 return this->c_str();
00544 }
00545 #endif
00547
00550 public:
00551 static size_type get(char_type* buffer, size_type cchBuffer)
00552 {
00553 return (policy_type::get_fn())(buffer, cchBuffer);
00554 }
00556
00559 private:
00560 buffer_type m_buffer;
00562 };
00563
00581 template <ss_typename_param_k P>
00582 class special_string_instance_1
00583 {
00586 public:
00588 typedef P policy_type;
00590 typedef special_string_instance_1<P> class_type;
00592 typedef ss_typename_type_k policy_type::char_type char_type;
00594 typedef ss_typename_type_k policy_type::size_type size_type;
00596 typedef ss_typename_type_k policy_type::argument_0_type argument_0_type;
00597
00602 private:
00603 enum { charTypeIsAnsi = is_same_type<ss_char_a_t, char_type>::value };
00604 public:
00605 typedef ss_typename_type_k select_first_type_if<
00606 ss_char_a_t const*
00607 , void
00608 , charTypeIsAnsi
00609 >::type cstring_a_type;
00614 private:
00615 enum { charTypeIsWide = is_same_type<ss_char_w_t, char_type>::value };
00616 public:
00617 typedef ss_typename_type_k select_first_type_if<
00618 ss_char_w_t const*
00619 , void
00620 , charTypeIsWide
00621 >::type cstring_w_type;
00622 private:
00623 typedef ss_typename_type_k policy_type::pfn_type pfn_type;
00624 private:
00625
00626
00627
00628 typedef ss_typename_type_k policy_type::allocator_type putative_allocator_type;
00629 enum
00630 {
00631 policy_has_allocator_type = (0 != size_of<putative_allocator_type>::value)
00632 };
00633 typedef ss_typename_type_k allocator_selector<char_type>::allocator_type backup_allocator_type;
00634 public:
00636 typedef ss_typename_type_k select_first_type_if<
00637 putative_allocator_type
00638 , backup_allocator_type
00639 , policy_has_allocator_type
00640 >::type allocator_type;
00641
00643 private:
00644 enum { allowImplicitConversion = policy_type::allowImplicitConversion };
00645 public:
00646 typedef ss_typename_type_k select_first_type_if<
00647 char_type const*
00648 , void
00649 , allowImplicitConversion
00650 >::type implicit_conversion_type;
00651 private:
00652
00653
00654
00655
00656
00657 enum
00658 {
00659 policy_indicates_shared_state = (0 != policy_type::sharedState)
00660 };
00661
00662 enum { internalBufferSize = policy_type::internalBufferSize };
00663 typedef ssi_buffer_static<
00664 char_type
00665 , internalBufferSize
00666 , allocator_type
00667 , argument_0_type
00668 , policy_type
00669 > ssi_buffer_static_type;
00670 typedef ssi_buffer_non_static<
00671 char_type
00672 , internalBufferSize
00673 , allocator_type
00674 , argument_0_type
00675 > ssi_buffer_non_static_type;
00676
00677 typedef ss_typename_type_k select_first_type_if<
00678 ssi_buffer_static_type
00679 , ssi_buffer_non_static_type
00680 , policy_indicates_shared_state
00681 >::type buffer_type;
00682
00684
00687 public:
00688 special_string_instance_1(argument_0_type argument)
00689 : m_buffer(argument, policy_type::get_fn())
00690 {}
00692
00695 public:
00696 static size_type get(argument_0_type argument, char_type* buffer, size_type cchBuffer)
00697 {
00698 return (policy_type::get_fn())(argument, buffer, cchBuffer);
00699 }
00701
00704 public:
00705 char_type const* c_str() const
00706 {
00707 return m_buffer.data();
00708 }
00709 char_type const* data() const
00710 {
00711 return m_buffer.data();
00712 }
00713 size_type length() const
00714 {
00715 return m_buffer.length();
00716 }
00717 size_type size() const
00718 {
00719 return length();
00720 }
00721
00722 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00723 cstring_a_type c_str_a() const
00724 {
00725 return c_str();
00726 }
00727 cstring_w_type c_str_w() const
00728 {
00729 return c_str();
00730 }
00731 #endif
00733
00736 public:
00737 #if !defined(STLSOFT_COMPILER_IS_BORLAND)
00738 operator implicit_conversion_type () const
00739 {
00740 return this->c_str();
00741 }
00742 #endif
00744
00747 private:
00748 buffer_type m_buffer;
00750 };
00751
00752
00753
00754
00755
00760 template <ss_typename_param_k P>
00761 inline ss_typename_type_ret_k special_string_instance_0<P>::char_type const* c_str_ptr_null(stlsoft_ns_qual(special_string_instance_0)<P> const& ssi)
00762 {
00763 return (0 != ssi.length()) ? ssi.c_str() : NULL;
00764 }
00765 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00766 template <ss_typename_param_k P>
00767 inline ss_typename_type_ret_k special_string_instance_0<P>::cstring_a_type c_str_ptr_null_a(stlsoft_ns_qual(special_string_instance_0)<P> const& ssi)
00768 {
00769 return (0 != ssi.length()) ? ssi.c_str_a() : NULL;
00770 }
00771 template <ss_typename_param_k P>
00772 inline ss_typename_type_ret_k special_string_instance_0<P>::cstring_w_type c_str_ptr_null_w(stlsoft_ns_qual(special_string_instance_0)<P> const& ssi)
00773 {
00774 return (0 != ssi.length()) ? ssi.c_str_w() : NULL;
00775 }
00776 #endif
00777
00782 template <ss_typename_param_k P>
00783 inline ss_typename_type_ret_k special_string_instance_0<P>::char_type const* c_str_ptr(stlsoft_ns_qual(special_string_instance_0)<P> const& ssi)
00784 {
00785 return ssi.c_str();
00786 }
00787 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00788 template <ss_typename_param_k P>
00789 inline ss_typename_type_ret_k special_string_instance_0<P>::cstring_a_type c_str_ptr_a(stlsoft_ns_qual(special_string_instance_0)<P> const& ssi)
00790 {
00791 return ssi.c_str_a();
00792 }
00793 template <ss_typename_param_k P>
00794 inline ss_typename_type_ret_k special_string_instance_0<P>::cstring_w_type c_str_ptr_w(stlsoft_ns_qual(special_string_instance_0)<P> const& ssi)
00795 {
00796 return ssi.c_str_w();
00797 }
00798 #endif
00799
00804 template <ss_typename_param_k P>
00805 inline ss_typename_type_ret_k special_string_instance_0<P>::char_type const* c_str_data(stlsoft_ns_qual(special_string_instance_0)<P> const& ssi)
00806 {
00807 return ssi.c_str();
00808 }
00809 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00810 template <ss_typename_param_k P>
00811 inline ss_typename_type_ret_k special_string_instance_0<P>::cstring_a_type c_str_data_a(stlsoft_ns_qual(special_string_instance_0)<P> const& ssi)
00812 {
00813 return ssi.c_str_a();
00814 }
00815 template <ss_typename_param_k P>
00816 inline ss_typename_type_ret_k special_string_instance_0<P>::cstring_w_type c_str_data_w(stlsoft_ns_qual(special_string_instance_0)<P> const& ssi)
00817 {
00818 return ssi.c_str_w();
00819 }
00820 #endif
00821
00826 template <ss_typename_param_k P>
00827 inline ss_size_t c_str_len(stlsoft_ns_qual(special_string_instance_0)<P> const& ssi)
00828 {
00829 return ssi.length();
00830 }
00831 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00832 template <ss_typename_param_k P>
00833 inline ss_size_t c_str_len_a(stlsoft_ns_qual(special_string_instance_0)<P> const& ssi)
00834 {
00835
00836
00837
00838 ss_char_a_t const *special_string_instance_must_use_narrow_character = ssi.c_str_a();
00839
00840 STLSOFT_SUPPRESS_UNUSED(special_string_instance_must_use_narrow_character);
00841
00842 return ssi.length();
00843 }
00844 template <ss_typename_param_k P>
00845 inline ss_size_t c_str_len_w(stlsoft_ns_qual(special_string_instance_0)<P> const& ssi)
00846 {
00847
00848
00849
00850 ss_char_w_t const *special_string_instance_must_use_wide_character = ssi.c_str_w();
00851
00852 STLSOFT_SUPPRESS_UNUSED(special_string_instance_must_use_wide_character);
00853
00854 return ssi.length();
00855 }
00856 #endif
00857
00862 template <ss_typename_param_k P>
00863 inline ss_typename_type_ret_k special_string_instance_1<P>::char_type const* c_str_ptr_null(stlsoft_ns_qual(special_string_instance_1)<P> const& ssi)
00864 {
00865 return (0 != ssi.length()) ? ssi.c_str() : NULL;
00866 }
00867 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00868 template <ss_typename_param_k P>
00869 inline ss_typename_type_ret_k special_string_instance_1<P>::cstring_a_type c_str_ptr_null_a(stlsoft_ns_qual(special_string_instance_1)<P> const& ssi)
00870 {
00871 return (0 != ssi.length()) ? ssi.c_str_a() : NULL;
00872 }
00873 template <ss_typename_param_k P>
00874 inline ss_typename_type_ret_k special_string_instance_1<P>::cstring_w_type c_str_ptr_null_w(stlsoft_ns_qual(special_string_instance_1)<P> const& ssi)
00875 {
00876 return (0 != ssi.length()) ? ssi.c_str_w() : NULL;
00877 }
00878 #endif
00879
00884 template <ss_typename_param_k P>
00885 inline ss_typename_type_ret_k special_string_instance_1<P>::char_type const* c_str_ptr(stlsoft_ns_qual(special_string_instance_1)<P> const& ssi)
00886 {
00887 return ssi.c_str();
00888 }
00889 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00890 template <ss_typename_param_k P>
00891 inline ss_typename_type_ret_k special_string_instance_1<P>::cstring_a_type c_str_ptr_a(stlsoft_ns_qual(special_string_instance_1)<P> const& ssi)
00892 {
00893 return ssi.c_str_a();
00894 }
00895 template <ss_typename_param_k P>
00896 inline ss_typename_type_ret_k special_string_instance_1<P>::cstring_w_type c_str_ptr_w(stlsoft_ns_qual(special_string_instance_1)<P> const& ssi)
00897 {
00898 return ssi.c_str_w();
00899 }
00900 #endif
00901
00906 template <ss_typename_param_k P>
00907 inline ss_typename_type_ret_k special_string_instance_1<P>::char_type const* c_str_data(stlsoft_ns_qual(special_string_instance_1)<P> const& ssi)
00908 {
00909 return ssi.c_str();
00910 }
00911 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00912 template <ss_typename_param_k P>
00913 inline ss_typename_type_ret_k special_string_instance_1<P>::cstring_a_type c_str_data_a(stlsoft_ns_qual(special_string_instance_1)<P> const& ssi)
00914 {
00915 return ssi.c_str_a();
00916 }
00917 template <ss_typename_param_k P>
00918 inline ss_typename_type_ret_k special_string_instance_1<P>::cstring_w_type c_str_data_w(stlsoft_ns_qual(special_string_instance_1)<P> const& ssi)
00919 {
00920 return ssi.c_str_w();
00921 }
00922 #endif
00923
00928 template <ss_typename_param_k P>
00929 inline ss_size_t c_str_len(stlsoft_ns_qual(special_string_instance_1)<P> const& ssi)
00930 {
00931 return ssi.length();
00932 }
00933 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00934 template <ss_typename_param_k P>
00935 inline ss_size_t c_str_len_a(stlsoft_ns_qual(special_string_instance_1)<P> const& ssi)
00936 {
00937
00938
00939
00940 ss_char_a_t const *special_string_instance_must_use_narrow_character = ssi.c_str_a();
00941
00942 STLSOFT_SUPPRESS_UNUSED(special_string_instance_must_use_narrow_character);
00943
00944 return ssi.length();
00945 }
00946 template <ss_typename_param_k P>
00947 inline ss_size_t c_str_len_w(stlsoft_ns_qual(special_string_instance_1)<P> const& ssi)
00948 {
00949
00950
00951
00952 ss_char_w_t const *special_string_instance_must_use_wide_character = ssi.c_str_w();
00953
00954 STLSOFT_SUPPRESS_UNUSED(special_string_instance_must_use_wide_character);
00955
00956 return ssi.length();
00957 }
00958 #endif
00959
00960
00961
00962 #ifndef _STLSOFT_NO_NAMESPACE
00963 }
00964 #endif
00965
00966
00967
00968 #endif
00969
00970