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
00049 #ifndef INETSTL_INCL_INETSTL_FILESYSTEM_HPP_FINDFILE_SEQUENCE
00050 #define INETSTL_INCL_INETSTL_FILESYSTEM_HPP_FINDFILE_SEQUENCE
00051
00052 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00053 # define INETSTL_VER_INETSTL_FILESYSTEM_HPP_FINDFILE_SEQUENCE_MAJOR 3
00054 # define INETSTL_VER_INETSTL_FILESYSTEM_HPP_FINDFILE_SEQUENCE_MINOR 0
00055 # define INETSTL_VER_INETSTL_FILESYSTEM_HPP_FINDFILE_SEQUENCE_REVISION 11
00056 # define INETSTL_VER_INETSTL_FILESYSTEM_HPP_FINDFILE_SEQUENCE_EDIT 139
00057 #endif
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073 #ifndef INETSTL_INCL_INETSTL_H_INETSTL
00074 # include <inetstl/inetstl.h>
00075 #endif
00076 #ifndef INETSTL_OS_IS_WINDOWS
00077 # error This file is currently compatible only with the Win32/Win64 API
00078 #endif
00079 #ifndef INETSTL_INCL_INETSTL_FILESYSTEM_HPP_FILESYSTEM_TRAITS
00080 # include <inetstl/filesystem/filesystem_traits.hpp>
00081 #endif
00082 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
00083 # ifndef INETSTL_INCL_INETSTL_ERROR_HPP_EXCEPTIONS
00084 # include <inetstl/error/exceptions.hpp>
00085 # endif
00086 #else
00087 # ifndef STLSOFT_INCL_STLSOFT_ERROR_HPP_EXCEPTIONS
00088 # include <stlsoft/error/exceptions.hpp>
00089 # endif
00090 #endif
00091 #ifndef STLSOFT_INCL_STLSOFT_COLLECTIONS_UTIL_HPP_COLLECTIONS
00092 # include <stlsoft/collections/util/collections.hpp>
00093 #endif
00094 #ifndef STLSOFT_INCL_STLSOFT_STRING_HPP_SIMPLE_STRING
00095 # include <stlsoft/string/simple_string.hpp>
00096 #endif
00097 #ifndef STLSOFT_INCL_STLSOFT_STRING_HPP_TOKENISER_FUNCTIONS
00098 # include <stlsoft/string/tokeniser_functions.hpp>
00099 #endif
00100 #ifndef STLSOFT_INCL_STLSOFT_UTIL_STD_HPP_ITERATOR_HELPER
00101 # include <stlsoft/util/std/iterator_helper.hpp>
00102 #endif
00103 #ifndef STLSOFT_INCL_STLSOFT_SHIMS_ACCESS_HPP_STRING
00104 # include <stlsoft/shims/access/string.hpp>
00105 #endif
00106
00107 #ifdef STLSOFT_UNITTEST
00108 # include <stlsoft/conversion/integer_to_string.hpp>
00109 # include <inetstl/network/connection.hpp>
00110 # include <inetstl/network/session.hpp>
00111 # include <stdio.h>
00112 # include <string.h>
00113 #endif
00114
00115
00116
00117
00118
00119 #ifndef _INETSTL_NO_NAMESPACE
00120 # if defined(_STLSOFT_NO_NAMESPACE) || \
00121 defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
00122
00123 namespace inetstl
00124 {
00125 # else
00126
00127
00128 namespace stlsoft
00129 {
00130
00131 namespace inetstl_project
00132 {
00133
00134 # endif
00135 #endif
00136
00137
00138
00139
00140
00141 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00142
00143 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
00144 class basic_findfile_sequence;
00145
00146 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
00147 class basic_findfile_sequence_value_type;
00148
00149 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
00150 class basic_findfile_sequence_const_input_iterator;
00151
00152 #endif
00153
00154
00155
00156
00157
00158
00171 template< ss_typename_param_k C
00172 #ifdef STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_CLASS_ARGUMENT_SUPPORT
00173 , ss_typename_param_k T = filesystem_traits<C>
00174 # ifdef STLSOFT_CF_EXCEPTION_SUPPORT
00175 , ss_typename_param_k X = throw_internet_exception_policy
00176 # else
00177 , ss_typename_param_k X = stlsoft_ns_qual(null_exception_policy)
00178 # endif
00179 #else
00180 , ss_typename_param_k T
00181 , ss_typename_param_k X
00182 #endif
00183 >
00184 class basic_findfile_sequence
00185 : public stlsoft_ns_qual(stl_collection_tag)
00186 {
00189 public:
00191 typedef C char_type;
00193 typedef X exception_policy_type;
00195 typedef ss_typename_param_k exception_policy_type::thrown_type thrown_type;
00197 typedef T traits_type;
00199 typedef basic_findfile_sequence<C, T, X> class_type;
00201 typedef basic_findfile_sequence_value_type<C, T, X> value_type;
00203 typedef basic_findfile_sequence_const_input_iterator<C, T, X, value_type> const_input_iterator;
00205 typedef const_input_iterator const_iterator;
00207 typedef value_type& reference;
00209 typedef value_type const& const_reference;
00211 typedef ss_typename_type_k traits_type::find_data_type find_data_type;
00213 typedef is_ptrdiff_t difference_type;
00215 typedef is_size_t size_type;
00217 typedef is_bool_t bool_type;
00218 private:
00219 typedef is_sint_t flags_type;
00220 typedef stlsoft_ns_qual(basic_simple_string)<char_type> string_type;
00222
00225 public:
00226 enum search_flags
00227 {
00228 includeDots = 0x0008
00229 , directories = 0x0010
00230 , files = 0x0020
00231 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00232 , noSort = 0
00233 #endif
00234 };
00236
00239 public:
00241 basic_findfile_sequence(HINTERNET hconn
00242 , char_type const* pattern
00243 , flags_type flags = directories | files);
00245 basic_findfile_sequence(HINTERNET hconn
00246 , char_type const* directory
00247 , char_type const* pattern
00248 , flags_type flags = directories | files);
00250 basic_findfile_sequence(HINTERNET hconn
00251 , char_type const* directory
00252 , char_type const* patterns
00253 , char_type delim
00254 , flags_type flags = directories | files);
00256 ~basic_findfile_sequence() stlsoft_throw_0();
00258
00261 public:
00265 const_iterator begin() const;
00269 const_iterator end() const;
00271
00274 public:
00278 char_type const* get_directory(size_type* pn = NULL) const;
00280
00283 public:
00284 #ifdef STLSOFT_OBSOLETE
00289 size_type size() const;
00290 #endif
00292 bool_type empty() const;
00294 static size_type max_size();
00296
00299 private:
00300 friend class basic_findfile_sequence_value_type<C, T, X>;
00301 friend class basic_findfile_sequence_const_input_iterator<C, T, X, value_type>;
00302
00303 const HINTERNET m_hconn;
00304 const char_type m_delim;
00305 const flags_type m_flags;
00306 const string_type m_rootDir;
00307 const string_type m_patterns;
00309
00312 private:
00313 bool_type is_valid() const;
00315
00318 private:
00319 static flags_type validate_flags_(flags_type flags);
00320 static void extract_subpath_(HINTERNET hconn, char_type *dest, char_type const* pattern);
00321
00322 static HINTERNET find_first_file_(HINTERNET hconn, char_type const* spec, flags_type flags, find_data_type *findData);
00324
00327 private:
00328 basic_findfile_sequence(class_type const&);
00329 class_type& operator =(class_type const&);
00331 };
00332
00333
00334
00335
00336
00341 typedef basic_findfile_sequence<is_char_a_t
00342 , filesystem_traits<is_char_a_t>
00343 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
00344 , throw_internet_exception_policy
00345 #else
00346 , stlsoft_ns_qual(null_exception_policy)
00347 #endif
00348 > findfile_sequence_a;
00353 typedef basic_findfile_sequence<is_char_w_t
00354 , filesystem_traits<is_char_w_t>
00355 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
00356 , throw_internet_exception_policy
00357 #else
00358 , stlsoft_ns_qual(null_exception_policy)
00359 #endif
00360 > findfile_sequence_w;
00365 typedef basic_findfile_sequence<TCHAR
00366 , filesystem_traits<TCHAR>
00367 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
00368 , throw_internet_exception_policy
00369 #else
00370 , stlsoft_ns_qual(null_exception_policy)
00371 #endif
00372 > findfile_sequence;
00373
00374
00375
00376
00381 template< ss_typename_param_k C
00382 , ss_typename_param_k T
00383 , ss_typename_param_k X
00384 >
00385 class basic_findfile_sequence_value_type
00386 {
00389 private:
00390 typedef basic_findfile_sequence<C, T, X> sequence_type;
00391 public:
00393 typedef C char_type;
00395 typedef X exception_policy_type;
00397 typedef ss_typename_param_k exception_policy_type::thrown_type thrown_type;
00399 typedef T traits_type;
00401 typedef basic_findfile_sequence_value_type<C, T, X> class_type;
00403 typedef ss_typename_type_k traits_type::find_data_type find_data_type;
00405 typedef ss_typename_type_k sequence_type::size_type size_type;
00406 private:
00407 typedef ss_typename_type_k sequence_type::bool_type bool_type;
00408 typedef ss_typename_type_k sequence_type::flags_type flags_type;
00409 typedef stlsoft_ns_qual(basic_simple_string)<char_type> string_type;
00411
00414 public:
00416 basic_findfile_sequence_value_type();
00417 private:
00418 basic_findfile_sequence_value_type(find_data_type const& data, char_type const* path, size_type cchPath)
00419 : m_data(data)
00420 {
00421 INETSTL_ASSERT(NULL != path || 0 == cchPath);
00422
00423 INETSTL_ASSERT(cchPath < STLSOFT_NUM_ELEMENTS(m_path));
00424 STLSOFT_SUPPRESS_UNUSED(cchPath);
00425
00426 size_type cchFile = traits_type::str_len(data.cFileName);
00427
00428 if('/' != data.cFileName[0])
00429 {
00430 traits_type::char_copy(m_path, path, cchPath + 1);
00431 if(!traits_type::has_dir_end(m_path))
00432 {
00433 traits_type::ensure_dir_end(m_path);
00434 ++cchPath;
00435 }
00436 }
00437 else
00438 {
00439 m_path[0] = '\0';
00440 cchPath = 0u;
00441 }
00442 traits_type::char_copy(m_path + cchPath, data.cFileName, cchFile + 1);
00443 }
00444
00445
00450
00451 public:
00453 find_data_type const& get_find_data() const;
00454 #ifdef STLSOFT_OBSOLETE
00458 find_data_type const& GetFindData() const; // Deprecated
00459 #endif
00460
00462 char_type const* get_filename() const;
00464 char_type const* get_short_filename() const;
00466 char_type const* get_path() const;
00468 char_type const* c_str() const;
00469
00471 operator char_type const* () const;
00472
00474 is_bool_t is_directory() const;
00476 is_bool_t is_file() const;
00478 is_bool_t is_read_only() const;
00479
00480 is_bool_t equal(char_type const* rhs) const;
00481 is_bool_t equal(class_type const& rhs) const;
00482
00483
00486 private:
00487 friend class basic_findfile_sequence_const_input_iterator<C, T, X, class_type>;
00488
00489 find_data_type m_data;
00490 char_type m_path[1 + _MAX_PATH];
00492 };
00493
00494
00499 template< ss_typename_param_k C
00500 , ss_typename_param_k T
00501 , ss_typename_param_k X
00502 , ss_typename_param_k V
00503 >
00504 class basic_findfile_sequence_const_input_iterator
00505 #ifndef STLSOFT_COMPILER_IS_WATCOM
00506 : public stlsoft_ns_qual(iterator_base)<inetstl_ns_qual_std(input_iterator_tag)
00507 , V
00508 , is_ptrdiff_t
00509 , void
00510 , V
00511 >
00512 #endif
00513 {
00516 private:
00517 typedef basic_findfile_sequence<C, T, X> sequence_type;
00518 public:
00520 typedef C char_type;
00522 typedef X exception_policy_type;
00524 typedef ss_typename_param_k exception_policy_type::thrown_type thrown_type;
00526 typedef T traits_type;
00528 typedef V value_type;
00530 typedef basic_findfile_sequence_const_input_iterator<C, T, X, V> class_type;
00532 typedef ss_typename_type_k traits_type::find_data_type find_data_type;
00534 typedef ss_typename_type_k sequence_type::size_type size_type;
00535 private:
00536 typedef ss_typename_type_k sequence_type::bool_type bool_type;
00537 typedef ss_typename_type_k sequence_type::flags_type flags_type;
00538 typedef ss_typename_type_k sequence_type::string_type string_type;
00540
00543 private:
00544 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00545 struct shared_handle
00546 {
00549 public:
00550 typedef shared_handle class_type;
00551 typedef HINTERNET handle_type;
00553
00556 public:
00557 handle_type hSrch;
00558 private:
00559 ss_sint32_t m_refCount;
00561
00564 public:
00565 ss_explicit_k shared_handle(handle_type h)
00566 : hSrch(h)
00567 , m_refCount(1)
00568 {}
00569 # if defined(STLSOFT_CF_COMPILER_WARNS_NO_PUBLIC_DTOR)
00570 protected:
00571 # else
00572 private:
00573 # endif
00574 ~shared_handle() stlsoft_throw_0()
00575 {
00576 INETSTL_MESSAGE_ASSERT("Shared search handle being destroyed with outstanding references!", 0 == m_refCount);
00577
00578 if(NULL != hSrch)
00579 {
00580 traits_type::find_close(hSrch);
00581 }
00582 }
00584
00587 public:
00588 ss_sint32_t AddRef()
00589 {
00590 return ++m_refCount;
00591 }
00592 ss_sint32_t Release()
00593 {
00594 ss_sint32_t rc = --m_refCount;
00595
00596 if(0 == rc)
00597 {
00598 delete this;
00599 }
00600
00601 return rc;
00602 }
00604
00607 private:
00608 shared_handle(class_type const&);
00609 class_type& operator =(class_type const&);
00611 };
00612 #endif
00614
00617 private:
00618 basic_findfile_sequence_const_input_iterator(
00619 sequence_type const& l
00620 , char_type const* rootDir
00621 , char_type const* patterns
00622 , char_type delim
00623 , flags_type flags
00624 );
00625 basic_findfile_sequence_const_input_iterator( sequence_type const& l);
00626 public:
00628 basic_findfile_sequence_const_input_iterator();
00630 basic_findfile_sequence_const_input_iterator(class_type const& rhs);
00632 ~basic_findfile_sequence_const_input_iterator() stlsoft_throw_0();
00633
00634
00635 basic_findfile_sequence_const_input_iterator& operator =(class_type const& rhs);
00637
00640 public:
00642 class_type& operator ++();
00644 class_type operator ++(int);
00646 const value_type operator *() const;
00648 is_bool_t equal(class_type const& rhs) const;
00650
00653 private:
00654 static int find_next_pattern_(char_type const*& p0, char_type const*& p1, char_type delim);
00655 static HINTERNET find_first_file_(HINTERNET hconn, char_type const* spec, flags_type flags, find_data_type *findData);
00657
00660 private:
00661 friend class basic_findfile_sequence<C, T, X>;
00662
00663 sequence_type const* const m_list;
00664 shared_handle* m_handle;
00665 ss_typename_type_k traits_type::find_data_type m_data;
00666 char_type const* m_rootDir;
00667 char_type const* m_pattern0;
00668 char_type const* m_pattern1;
00669 char_type m_delim;
00670 flags_type m_flags;
00672 };
00673
00675
00676
00677
00678
00679 template< ss_typename_param_k C
00680 , ss_typename_param_k T
00681 , ss_typename_param_k X
00682 , ss_typename_param_k V
00683 >
00684 inline is_bool_t operator ==( basic_findfile_sequence_const_input_iterator<C, T, X, V> const& lhs
00685 , basic_findfile_sequence_const_input_iterator<C, T, X, V> const& rhs)
00686 {
00687 return lhs.equal(rhs);
00688 }
00689
00690 template< ss_typename_param_k C
00691 , ss_typename_param_k T
00692 , ss_typename_param_k X
00693 , ss_typename_param_k V
00694 >
00695 inline is_bool_t operator !=( basic_findfile_sequence_const_input_iterator<C, T, X, V> const& lhs
00696 , basic_findfile_sequence_const_input_iterator<C, T, X, V> const& rhs)
00697 {
00698 return !lhs.equal(rhs);
00699 }
00700
00701
00702
00703 template< ss_typename_param_k C
00704 , ss_typename_param_k T
00705 , ss_typename_param_k X
00706 >
00707 inline is_bool_t operator == ( basic_findfile_sequence_value_type<C, T, X> const& lhs
00708 , basic_findfile_sequence_value_type<C, T, X> const& rhs)
00709 {
00710 return lhs.equal(rhs);
00711 }
00712
00713 template< ss_typename_param_k C
00714 , ss_typename_param_k T
00715 , ss_typename_param_k X
00716 >
00717 inline is_bool_t operator == ( basic_findfile_sequence_value_type<C, T, X> const& lhs
00718 , C const* rhs)
00719 {
00720 return lhs.equal(rhs);
00721 }
00722
00723 template< ss_typename_param_k C
00724 , ss_typename_param_k T
00725 , ss_typename_param_k X
00726 >
00727 inline is_bool_t operator == (C const* lhs, basic_findfile_sequence_value_type<C, T, X> const& rhs)
00728 {
00729 return rhs.equal(lhs);
00730 }
00731
00732 template< ss_typename_param_k C
00733 , ss_typename_param_k T
00734 , ss_typename_param_k X
00735 >
00736 inline is_bool_t operator != ( basic_findfile_sequence_value_type<C, T, X> const& lhs
00737 , basic_findfile_sequence_value_type<C, T, X> const& rhs)
00738 {
00739 return !lhs.equal(rhs);
00740 }
00741
00742 template< ss_typename_param_k C
00743 , ss_typename_param_k T
00744 , ss_typename_param_k X
00745 >
00746 inline is_bool_t operator != ( basic_findfile_sequence_value_type<C, T, X> const& lhs
00747 , C const* rhs)
00748 {
00749 return !lhs.equal(rhs);
00750 }
00751
00752 template< ss_typename_param_k C
00753 , ss_typename_param_k T
00754 , ss_typename_param_k X
00755 >
00756 inline is_bool_t operator != ( C const* lhs, basic_findfile_sequence_value_type<C, T, X> const& rhs)
00757 {
00758 return !rhs.equal(lhs);
00759 }
00760
00762
00763
00764 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00765
00766 template <ss_typename_param_k T, ss_typename_param_k X>
00767 inline is_char_a_t const* c_str_data_a(inetstl_ns_qual(basic_findfile_sequence_value_type)<is_char_a_t, T, X> const& v)
00768 {
00769 return v.get_path();
00770 }
00771 template <ss_typename_param_k T, ss_typename_param_k X>
00772 inline is_char_w_t const* c_str_data_w(inetstl_ns_qual(basic_findfile_sequence_value_type)<is_char_w_t, T, X> const& v)
00773 {
00774 return v.get_path();
00775 }
00776
00777 #endif
00778
00784 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
00785 inline C const* c_str_data(inetstl_ns_qual(basic_findfile_sequence_value_type)<C, T, X> const& v)
00786 {
00787 return v.get_path();
00788 }
00789
00790
00791
00792 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00793
00794 template <ss_typename_param_k T, ss_typename_param_k X>
00795 inline is_size_t c_str_len_a(inetstl_ns_qual(basic_findfile_sequence_value_type)<is_char_a_t, T, X> const& v)
00796 {
00797 return stlsoft_ns_qual(c_str_len_a(v.get_path()));
00798 }
00799 template <ss_typename_param_k T, ss_typename_param_k X>
00800 inline is_size_t c_str_len_w(inetstl_ns_qual(basic_findfile_sequence_value_type)<is_char_w_t, T, X> const& v)
00801 {
00802 return stlsoft_ns_qual(c_str_len_w(v.get_path()));
00803 }
00804
00805 #endif
00806
00811 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
00812 inline is_size_t c_str_len(inetstl_ns_qual(basic_findfile_sequence_value_type)<C, T, X> const& v)
00813 {
00814 return stlsoft_ns_qual(c_str_len(v.get_path()));
00815 }
00816
00817
00818
00819 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00820
00821 template <ss_typename_param_k T, ss_typename_param_k X>
00822 inline is_char_a_t const* c_str_ptr_a(inetstl_ns_qual(basic_findfile_sequence_value_type)<is_char_a_t, T, X> const& v)
00823 {
00824 return v.get_path();
00825 }
00826 template <ss_typename_param_k T, ss_typename_param_k X>
00827 inline is_char_w_t const* c_str_ptr_w(inetstl_ns_qual(basic_findfile_sequence_value_type)<is_char_w_t, T, X> const& v)
00828 {
00829 return v.get_path();
00830 }
00831
00832 #endif
00833
00838 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
00839 inline C const* c_str_ptr(inetstl_ns_qual(basic_findfile_sequence_value_type)<C, T, X> const& v)
00840 {
00841 return v.get_path();
00842 }
00843
00844
00845
00846 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00847
00848 template <ss_typename_param_k T, ss_typename_param_k X>
00849 inline is_char_a_t const* c_str_ptr_null_a(inetstl_ns_qual(basic_findfile_sequence_value_type)<is_char_a_t, T, X> const& v)
00850 {
00851 return stlsoft_ns_qual(c_str_ptr_null(v.get_path()));
00852 }
00853 template <ss_typename_param_k T, ss_typename_param_k X>
00854 inline is_char_w_t const* c_str_ptr_null_w(inetstl_ns_qual(basic_findfile_sequence_value_type)<is_char_w_t, T, X> const& v)
00855 {
00856 return stlsoft_ns_qual(c_str_ptr_null(v.get_path()));
00857 }
00858
00859 #endif
00860
00865 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
00866 inline C const* c_str_ptr_null(inetstl_ns_qual(basic_findfile_sequence_value_type)<C, T, X> const& v)
00867 {
00868 return stlsoft_ns_qual(c_str_ptr_null(v.get_path()));
00869 }
00870
00871
00872
00874
00875
00876 #ifdef STLSOFT_UNITTEST
00877 # include "./unittest/findfile_sequence_unittest_.h"
00878 #endif
00879
00881
00882
00883 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00884
00885
00886
00887 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
00888 inline HINTERNET basic_findfile_sequence<C, T, X>::find_first_file_(
00889 HINTERNET hconn
00890 , ss_typename_type_k basic_findfile_sequence<C, T, X>::char_type const* spec
00891 , ss_typename_type_k basic_findfile_sequence<C, T, X>::flags_type
00892 , ss_typename_type_k basic_findfile_sequence<C, T, X>::find_data_type* findData
00893 )
00894 {
00895 HINTERNET hSrch = traits_type::find_first_file(hconn, spec, findData);
00896
00897 if(NULL == hSrch)
00898 {
00899 DWORD dwErr = ::GetLastError();
00900
00901 if(ERROR_FTP_TRANSFER_IN_PROGRESS == dwErr)
00902 {
00903 exception_policy_type()("Already enumerating using current connection", dwErr);
00904 }
00905 else
00906 {
00907 exception_policy_type()("Search failed", dwErr);
00908 }
00909 }
00910
00911 return hSrch;
00912 }
00913
00914 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
00915 inline ss_typename_type_ret_k basic_findfile_sequence<C, T, X>::flags_type basic_findfile_sequence<C, T, X>::validate_flags_(ss_typename_type_k basic_findfile_sequence<C, T, X>::flags_type flags)
00916 {
00917 const flags_type validFlags = 0
00918 | includeDots
00919 | directories
00920 | files
00921 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00922 | noSort
00923 #endif
00924 | 0;
00925
00926 INETSTL_MESSAGE_ASSERT("Specification of unrecognised/unsupported flags", flags == (flags & validFlags));
00927 STLSOFT_SUPPRESS_UNUSED(validFlags);
00928
00929 if(0 == (flags & (directories | files)))
00930 {
00931 flags |= (directories | files);
00932 }
00933
00934 return flags;
00935 }
00936
00937 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
00938 inline is_bool_t basic_findfile_sequence<C, T, X>::is_valid() const
00939 {
00940 return true;
00941 }
00942
00943 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
00944 inline void basic_findfile_sequence<C, T, X>::extract_subpath_(HINTERNET hconn, char_type *dest, char_type const* pattern)
00945 {
00946 char_type* pFile;
00947
00948 traits_type::get_full_path_name(hconn, pattern, _MAX_PATH, dest, &pFile);
00949
00950 if(NULL != pFile)
00951 {
00952 *pFile = '\0';
00953 }
00954 }
00955
00956
00957 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
00958 inline basic_findfile_sequence<C, T, X>::basic_findfile_sequence(HINTERNET hconn, char_type const* pattern, ss_typename_type_k basic_findfile_sequence<C, T, X>::flags_type flags )
00959 : m_hconn(hconn)
00960 , m_delim('\0')
00961 , m_flags(validate_flags_(flags))
00962 , m_rootDir()
00963 , m_patterns(pattern)
00964 {
00965 INETSTL_ASSERT(is_valid());
00966 }
00967
00968 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
00969 inline basic_findfile_sequence<C, T, X>::basic_findfile_sequence(HINTERNET hconn, char_type const* directory, char_type const* pattern, ss_typename_type_k basic_findfile_sequence<C, T, X>::flags_type flags )
00970 : m_hconn(hconn)
00971 , m_delim('\0')
00972 , m_flags(validate_flags_(flags))
00973 , m_rootDir(directory)
00974 , m_patterns(pattern)
00975 {
00976 INETSTL_ASSERT(is_valid());
00977 }
00978
00979 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
00980 inline basic_findfile_sequence<C, T, X>::basic_findfile_sequence(
00981 HINTERNET hconn
00982 , char_type const* directory
00983 , char_type const* patterns
00984 , char_type delim
00985 , ss_typename_type_k basic_findfile_sequence<C, T, X>::flags_type flags
00986 )
00987 : m_hconn(hconn)
00988 , m_delim(delim)
00989 , m_flags(validate_flags_(flags))
00990 , m_rootDir(directory)
00991 , m_patterns(patterns)
00992 {
00993 INETSTL_ASSERT(is_valid());
00994 }
00995
00996 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
00997 inline basic_findfile_sequence<C, T, X>::~basic_findfile_sequence() stlsoft_throw_0()
00998 {
00999 INETSTL_ASSERT(is_valid());
01000 }
01001
01002
01003 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
01004 inline ss_typename_type_ret_k basic_findfile_sequence<C, T, X>::const_iterator basic_findfile_sequence<C, T, X>::begin() const
01005 {
01006 INETSTL_ASSERT(is_valid());
01007
01008 return const_input_iterator(*this, stlsoft_ns_qual(c_str_ptr)(m_rootDir), stlsoft_ns_qual(c_str_ptr)(m_patterns), m_delim, m_flags);
01009 }
01010
01011 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
01012 inline ss_typename_type_ret_k basic_findfile_sequence<C, T, X>::const_iterator basic_findfile_sequence<C, T, X>::end() const
01013 {
01014 INETSTL_ASSERT(is_valid());
01015
01016 return const_input_iterator(*this);
01017 }
01018
01019
01020 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
01021 ss_typename_type_k basic_findfile_sequence<C, T, X>::char_type const* basic_findfile_sequence<C, T, X>::get_directory(ss_typename_type_k basic_findfile_sequence<C, T, X>::size_type* pn) const
01022 {
01023 INETSTL_ASSERT(is_valid());
01024
01025 size_type n_;
01026
01027 if(NULL == pn)
01028 {
01029 pn = &n_;
01030 }
01031
01032 *pn = m_rootDir.size();
01033
01034 return m_rootDir.c_str();
01035 }
01036
01037
01038 #ifdef STLSOFT_OBSOLETE
01039 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
01040 inline ss_typename_type_ret_k basic_findfile_sequence<C, T, X>::size_type basic_findfile_sequence<C, T, X>::size() const
01041 {
01042 INETSTL_ASSERT(is_valid());
01043
01044 return stlsoft_ns_qual_std(distance)(begin(), end());
01045 }
01046 #endif
01047
01048 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
01049 inline is_bool_t basic_findfile_sequence<C, T, X>::empty() const
01050 {
01051 INETSTL_ASSERT(is_valid());
01052
01053 return begin() == end();
01054 }
01055
01056 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
01057 inline ss_typename_type_ret_k basic_findfile_sequence<C, T, X>::size_type basic_findfile_sequence<C, T, X>::max_size()
01058 {
01059 return static_cast<size_type>(-1);
01060 }
01061
01062
01063
01064 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
01065 inline basic_findfile_sequence_value_type<C, T, X>::basic_findfile_sequence_value_type()
01066 {
01067 m_data.dwFileAttributes = 0xFFFFFFFF;
01068 m_data.cFileName[0] = '\0';
01069 m_data.cAlternateFileName[0] = '\0';
01070 m_path[0] = '\0';
01071 }
01072
01073 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
01074 inline ss_typename_type_ret_k basic_findfile_sequence_value_type<C, T, X>::find_data_type const& basic_findfile_sequence_value_type<C, T, X>::get_find_data() const
01075 {
01076 return m_data;
01077 }
01078
01079 #ifdef STLSOFT_OBSOLETE
01080 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
01081 inline ss_typename_type_ret_k basic_findfile_sequence_value_type<C, T, X>::find_data_type const& basic_findfile_sequence_value_type<C, T, X>::GetFindData() const
01082 {
01083 return get_find_data();
01084 }
01085 #endif
01086
01087 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
01088 inline ss_typename_type_ret_k basic_findfile_sequence_value_type<C, T, X>::char_type const* basic_findfile_sequence_value_type<C, T, X>::get_filename() const
01089 {
01090 return m_data.cFileName;
01091 }
01092
01093 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
01094 inline ss_typename_type_ret_k basic_findfile_sequence_value_type<C, T, X>::char_type const* basic_findfile_sequence_value_type<C, T, X>::get_short_filename() const
01095 {
01096 return m_data.cAlternateFileName[0] != '\0' ? m_data.cAlternateFileName : m_data.cFileName;
01097 }
01098
01099 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
01100 inline ss_typename_type_ret_k basic_findfile_sequence_value_type<C, T, X>::char_type const* basic_findfile_sequence_value_type<C, T, X>::get_path() const
01101 {
01102 return &m_path[0];
01103 }
01104
01105 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
01106 inline ss_typename_type_ret_k basic_findfile_sequence_value_type<C, T, X>::char_type const* basic_findfile_sequence_value_type<C, T, X>::c_str() const
01107 {
01108 return get_path();
01109 }
01110
01111 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
01112 #if defined(STLSOFT_COMPILER_IS_GCC) || \
01113 ( defined(STLSOFT_COMPILER_IS_MSVC) && \
01114 _MSC_VER < 1100)
01115 inline basic_findfile_sequence_value_type<C, T, X>::operator C const* () const
01116 #else
01117 inline basic_findfile_sequence_value_type<C, T, X>::operator ss_typename_type_k basic_findfile_sequence_value_type<C, T, X>::char_type const* () const
01118 #endif
01119 {
01120 return get_path();
01121 }
01122
01123 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
01124 inline is_bool_t basic_findfile_sequence_value_type<C, T, X>::is_directory() const
01125 {
01126 return traits_type::is_directory(&m_data);
01127 }
01128 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
01129 inline is_bool_t basic_findfile_sequence_value_type<C, T, X>::is_file() const
01130 {
01131 return traits_type::is_file(&m_data);
01132 }
01133 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
01134 inline is_bool_t basic_findfile_sequence_value_type<C, T, X>::is_read_only() const
01135 {
01136 return 0 != (m_data.dwFileAttributes & FILE_ATTRIBUTE_READONLY);
01137 }
01138
01139 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
01140 inline is_bool_t basic_findfile_sequence_value_type<C, T, X>::equal(char_type const* rhs) const
01141 {
01142 INETSTL_ASSERT(NULL != rhs);
01143
01144 return 0 == traits_type::str_compare(this->get_path(), rhs);
01145 }
01146
01147 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
01148 inline is_bool_t basic_findfile_sequence_value_type<C, T, X>::equal(basic_findfile_sequence_value_type<C, T, X> const& rhs) const
01149 {
01150 return equal(rhs.get_path());
01151 }
01152
01153
01154
01155 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
01156 inline int basic_findfile_sequence_const_input_iterator<C, T, X, V>::find_next_pattern_( ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::char_type const*& p0
01157 , ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::char_type const*& p1
01158 , ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::char_type delim)
01159 {
01160 INETSTL_ASSERT(NULL != p0);
01161 INETSTL_ASSERT(NULL != p1);
01162 INETSTL_ASSERT(p0 <= p1);
01163
01164 return stlsoft_ns_qual(find_next_token)(p0, p1, delim);
01165 }
01166
01167 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
01168 inline HINTERNET basic_findfile_sequence_const_input_iterator<C, T, X, V>::find_first_file_( HINTERNET hconn
01169 #ifdef STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED
01170 , ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::char_type const* pattern
01171 , ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::flags_type flags
01172 , ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::find_data_type* findData)
01173 #else
01174 , char_type const* pattern
01175 , flags_type flags
01176 , find_data_type* findData)
01177 #endif
01178 {
01179 HINTERNET hSrch = traits_type::find_first_file(hconn, pattern, findData);
01180
01181 if(hSrch != NULL)
01182 {
01183
01184 for(; hSrch != NULL; )
01185 {
01186 if(0 == (findData->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
01187 {
01188
01189 if(flags & sequence_type::files)
01190 {
01191 break;
01192 }
01193 }
01194 else
01195 {
01196 if(traits_type::is_dots(findData->cFileName))
01197 {
01198 if(flags & sequence_type::includeDots)
01199 {
01200
01201 break;
01202 }
01203 }
01204 else if(flags & sequence_type::directories)
01205 {
01206
01207 break;
01208 }
01209 }
01210
01211 if(!traits_type::find_next_file(hSrch, findData))
01212 {
01213 traits_type::find_close(hSrch);
01214
01215 hSrch = NULL;
01216
01217 break;
01218 }
01219 }
01220 }
01221
01222 return hSrch;
01223 }
01224
01225 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
01226 inline basic_findfile_sequence_const_input_iterator<C, T, X, V>::basic_findfile_sequence_const_input_iterator()
01227 : m_list(NULL)
01228 , m_handle(NULL)
01229 , m_rootDir(NULL)
01230 , m_pattern0(NULL)
01231 , m_pattern1(NULL)
01232 , m_delim('\0')
01233 , m_flags(0)
01234 {}
01235
01236 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
01237 inline basic_findfile_sequence_const_input_iterator<C, T, X, V>::basic_findfile_sequence_const_input_iterator( sequence_type const& l
01238 #ifdef STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED
01239 , ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::char_type const* rootDir
01240 , ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::char_type const* patterns
01241 , ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::char_type delim
01242 , ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::flags_type flags)
01243 #else
01244 , char_type const* rootDir
01245 , char_type const* patterns
01246 , char_type delim
01247 , flags_type flags)
01248 #endif
01249 : m_list(&l)
01250 , m_handle(NULL)
01251 , m_rootDir(rootDir)
01252 , m_pattern0(patterns)
01253 , m_pattern1(patterns)
01254 , m_delim(delim)
01255 , m_flags(flags)
01256 {
01257 operator ++();
01258 }
01259
01260 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
01261 inline basic_findfile_sequence_const_input_iterator<C, T, X, V>::basic_findfile_sequence_const_input_iterator(sequence_type const& l)
01262 : m_list(&l)
01263 , m_handle(NULL)
01264 , m_rootDir(NULL)
01265 , m_pattern0(NULL)
01266 , m_pattern1(NULL)
01267 , m_delim('\0')
01268 , m_flags(0)
01269 {}
01270
01271 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
01272 inline basic_findfile_sequence_const_input_iterator<C, T, X, V>::basic_findfile_sequence_const_input_iterator(class_type const& rhs)
01273 : m_list(rhs.m_list)
01274 , m_handle(rhs.m_handle)
01275 , m_data(rhs.m_data)
01276 , m_rootDir(rhs.m_rootDir)
01277 , m_pattern0(rhs.m_pattern0)
01278 , m_pattern1(rhs.m_pattern1)
01279 , m_delim(rhs.m_delim)
01280 , m_flags(rhs.m_flags)
01281 {
01282 if(NULL != m_handle)
01283 {
01284 m_handle->AddRef();
01285 }
01286 }
01287
01288 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
01289 #ifndef STLSOFT_COMPILER_IS_WATCOM
01290 inline ss_typename_type_ret_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::class_type& basic_findfile_sequence_const_input_iterator<C, T, X, V>::operator =(ss_typename_param_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::class_type const& rhs)
01291 #else
01292 inline basic_findfile_sequence_const_input_iterator<C, T, X, V> &basic_findfile_sequence_const_input_iterator<C, T, X, V>::operator =(basic_findfile_sequence_const_input_iterator<C, T, X, V> const& rhs)
01293 #endif
01294 {
01295 INETSTL_MESSAGE_ASSERT("Assigning iterators from separate sequences", (NULL == m_list || NULL == rhs.m_list || m_list == rhs.m_list));
01296
01297 shared_handle* this_handle = m_handle;
01298
01299 m_handle = rhs.m_handle;
01300 m_data = rhs.m_data;
01301 m_rootDir = rhs.m_rootDir;
01302 m_pattern0 = rhs.m_pattern0;
01303 m_pattern1 = rhs.m_pattern1;
01304 m_delim = rhs.m_delim;
01305 m_flags = rhs.m_flags;
01306
01307 if(NULL != m_handle)
01308 {
01309 m_handle->AddRef();
01310 }
01311
01312 if(NULL != this_handle)
01313 {
01314 this_handle->Release();
01315 }
01316
01317 return *this;
01318 }
01319
01320 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
01321 inline basic_findfile_sequence_const_input_iterator<C, T, X, V>::~basic_findfile_sequence_const_input_iterator() stlsoft_throw_0()
01322 {
01323 if(NULL != m_handle)
01324 {
01325 m_handle->Release();
01326 }
01327 }
01328
01329 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
01330 inline ss_typename_type_ret_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::class_type& basic_findfile_sequence_const_input_iterator<C, T, X, V>::operator ++()
01331 {
01332 INETSTL_ASSERT(NULL != m_pattern0);
01333 INETSTL_ASSERT(NULL != m_pattern1);
01334
01335 INETSTL_MESSAGE_ASSERT("Attempting to increment an invalid iterator!", '\0' != *m_pattern0);
01336
01337
01338
01339
01340
01341
01342 for(; '\0' != *m_pattern0 || '\0' != *m_pattern1;)
01343 {
01344 if(NULL == m_handle)
01345 {
01346
01347
01348 while(find_next_pattern_(m_pattern0, m_pattern1, m_delim))
01349 {
01350 if(m_pattern1 != m_pattern0)
01351 {
01352 string_type pattern(m_pattern0, m_pattern1);
01353 string_type search = m_rootDir;
01354
01355 if(search.back() != '/')
01356 {
01357 static const char_type slash[] = { '/', '\0' };
01358
01359 search += slash;
01360 }
01361 search += pattern;
01362
01363
01364 HINTERNET hSrch = find_first_file_(m_list->m_hconn, stlsoft_ns_qual(c_str_ptr)(search), m_flags, &m_data);
01365
01366 if(NULL != hSrch)
01367 {
01368 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
01369 try
01370 {
01371 #endif
01372 m_handle = new shared_handle(hSrch);
01373
01374 if(NULL == m_handle)
01375 {
01376 ::FindClose(hSrch);
01377 }
01378 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
01379 }
01380 catch(...)
01381 {
01382 ::FindClose(hSrch);
01383
01384 throw;
01385 }
01386 #endif
01387
01388 return *this;
01389 }
01390 }
01391 }
01392 }
01393
01394 if(NULL != m_handle)
01395 {
01396 for(; m_handle->hSrch != NULL; )
01397 {
01398 if(!traits_type::find_next_file(m_handle->hSrch, &m_data))
01399 {
01400 m_handle->Release();
01401
01402 m_handle = NULL;
01403
01404 break;
01405 }
01406 else
01407 {
01408 if((m_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
01409 {
01410
01411 if(m_flags & sequence_type::files)
01412 {
01413 return *this;
01414 }
01415 }
01416 else
01417 {
01418 if(traits_type::is_dots(m_data.cFileName))
01419 {
01420 if(m_flags & sequence_type::includeDots)
01421 {
01422
01423 return *this;
01424 }
01425 }
01426 else if(m_flags & sequence_type::directories)
01427 {
01428
01429 return *this;
01430 }
01431 }
01432 }
01433 }
01434 }
01435 }
01436
01437 return *this;
01438 }
01439
01440 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
01441 inline ss_typename_type_ret_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::class_type basic_findfile_sequence_const_input_iterator<C, T, X, V>::operator ++(int)
01442 {
01443 class_type ret(*this);
01444
01445 operator ++();
01446
01447 return ret;
01448 }
01449
01450 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
01451 inline const ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::value_type basic_findfile_sequence_const_input_iterator<C, T, X, V>::operator *() const
01452 {
01453 if(NULL != m_handle)
01454 {
01455 size_type dirLen = 0;
01456 char_type const* dir = m_list->get_directory(&dirLen);
01457
01458 return value_type(m_data, dir, dirLen);
01459 }
01460 else
01461 {
01462 INETSTL_MESSAGE_ASSERT("Dereferencing end()-valued iterator", 0);
01463
01464 return value_type();
01465 }
01466 }
01467
01468 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
01469 inline is_bool_t basic_findfile_sequence_const_input_iterator<C, T, X, V>::equal(class_type const& rhs) const
01470 {
01471
01472 INETSTL_MESSAGE_ASSERT("Comparing iterators from separate sequences", (m_list == rhs.m_list || NULL == m_list || NULL == rhs.m_list));
01473
01474 return m_handle == rhs.m_handle;
01475 }
01476
01477 #endif
01478
01479
01480
01481 #ifndef _INETSTL_NO_NAMESPACE
01482 # if defined(_STLSOFT_NO_NAMESPACE) || \
01483 defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
01484 }
01485 # else
01486 }
01487 }
01488 # endif
01489 #endif
01490
01491
01492
01493
01494
01495
01496
01497
01498
01499 #ifndef _INETSTL_NO_NAMESPACE
01500 # if !defined(_STLSOFT_NO_NAMESPACE) && \
01501 !defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
01502 namespace stlsoft
01503 {
01504 # else
01505
01506 # endif
01507
01508 using ::inetstl::c_str_data;
01509 using ::inetstl::c_str_data_a;
01510 using ::inetstl::c_str_data_w;
01511
01512 using ::inetstl::c_str_len;
01513 using ::inetstl::c_str_len_a;
01514 using ::inetstl::c_str_len_w;
01515
01516 using ::inetstl::c_str_ptr;
01517 using ::inetstl::c_str_ptr_a;
01518 using ::inetstl::c_str_ptr_w;
01519
01520 using ::inetstl::c_str_ptr_null;
01521 using ::inetstl::c_str_ptr_null_a;
01522 using ::inetstl::c_str_ptr_null_w;
01523
01524 # if !defined(_STLSOFT_NO_NAMESPACE) && \
01525 !defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
01526 }
01527 # else
01528
01529 # endif
01530 #endif
01531
01532
01533
01534 #endif
01535
01536