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 #ifndef RECLS_INCL_RECLSTL_STL_HPP_SEARCH_SEQUENCE
00043 #define RECLS_INCL_RECLSTL_STL_HPP_SEARCH_SEQUENCE
00044
00045 #ifndef RECLS_DOCUMENTATION_SKIP_SECTION
00046 # define RECLS_VER_RECLSTL_STL_HPP_SEARCH_SEQUENCE_MAJOR 3
00047 # define RECLS_VER_RECLSTL_STL_HPP_SEARCH_SEQUENCE_MINOR 6
00048 # define RECLS_VER_RECLSTL_STL_HPP_SEARCH_SEQUENCE_REVISION 6
00049 # define RECLS_VER_RECLSTL_STL_HPP_SEARCH_SEQUENCE_EDIT 75
00050 #endif
00051
00064
00065
00066
00067
00068 #ifndef RECLS_INCL_RECLS_STL_HPP_RECLS
00069 # include <recls/stl/recls.hpp>
00070 #endif
00071 #ifndef RECLS_INCL_RECLS_STL_HPP_TRAITS
00072 # include <recls/stl/traits.hpp>
00073 #endif
00074 #include <platformstl/filesystem/file_path_buffer.hpp>
00075
00076 #include <stlsoft/string/simple_string.hpp>
00077
00078 #if defined(STLSOFT_COMPILER_IS_MSVC) && \
00079 _MSC_VER < 1310
00080 # include <iosfwd>
00081 #endif
00082
00083 #if defined(WIN32)
00084 # include <tchar.h>
00085 #endif
00086
00087
00088
00089
00090
00091 #if !defined(RECLS_NO_NAMESPACE)
00092 namespace recls
00093 {
00094
00095 namespace stl
00096 {
00097 #endif
00098
00099 typedef platformstl::basic_file_path_buffer<recls_char_t> file_path_buffer;
00100
00101
00102
00103
00104
00105 #ifndef RECLS_DOCUMENTATION_SKIP_SECTION
00106
00107 template< typename C
00108 , typename T
00109 >
00110 class basic_search_sequence_value_type;
00111
00112 template< typename C
00113 , typename T
00114 , typename V
00115 >
00116 class basic_search_sequence_const_iterator;
00117
00118 #endif
00119
00120
00121
00122
00123
00124 #ifndef RECLS_DOCUMENTATION_SKIP_SECTION
00125 struct rss_shared_handle
00126 {
00127 hrecls_t hSrch;
00128 recls_sint32_t cRefs;
00129
00130 public:
00131 explicit rss_shared_handle(hrecls_t h)
00132 : hSrch(h)
00133 , cRefs(1)
00134 {}
00135 void Release()
00136 {
00137 if(--cRefs == 0)
00138 {
00139 delete this;
00140 }
00141 }
00142 #if defined(STLSOFT_COMPILER_IS_GCC)
00143 protected:
00144 #else
00145 private:
00146 #endif
00147 ~rss_shared_handle()
00148 {
00149 RECLS_MESSAGE_ASSERT("Shared search handle being destroyed with outstanding references!", 0 == cRefs);
00150
00151 if(NULL != hSrch)
00152 {
00153 Recls_SearchClose(hSrch);
00154 }
00155 }
00156 };
00157 #endif
00158
00159
00160
00161
00162
00163
00170 template< typename C
00171 #ifdef STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_CLASS_ARGUMENT_SUPPORT
00172 , typename T = reclstl_traits<C>
00173 #else
00174 , typename T
00175 #endif
00176 >
00177 class basic_search_sequence
00178 {
00181 public:
00183 typedef C char_type;
00185 typedef T traits_type;
00187 typedef basic_search_sequence<C, T> class_type;
00189 typedef basic_search_sequence_value_type<C, T> value_type;
00191 typedef basic_search_sequence_const_iterator<C, T, value_type> const_iterator;
00193 typedef value_type &reference;
00195 typedef value_type const &const_reference;
00197 typedef ss_typename_type_k traits_type::entry_type entry_type;
00199 typedef size_t size_type;
00201 typedef ptrdiff_t difference_type;
00203 typedef stlsoft::basic_simple_string<C> string_type;
00205
00208 public:
00210 basic_search_sequence(char_type const *pattern, recls_uint32_t flags);
00211 #if defined(STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT)
00213 template <typename S>
00214 basic_search_sequence(S const &pattern, recls_uint32_t flags)
00215 : m_directory(copy_or_null_(m_directory_, static_cast<char_type const*>(NULL)))
00216 , m_pattern(copy_or_null_(m_pattern_, pattern))
00217 , m_flags(flags)
00218 {}
00219 #endif
00221 basic_search_sequence(char_type const *directory, char_type const *pattern, recls_uint32_t flags);
00222 #if defined(STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT)
00224 template <typename S1, typename S2>
00225 basic_search_sequence(S1 const &directory, S2 const &pattern, recls_uint32_t flags)
00226 : m_directory(copy_or_null_(m_directory_, directory))
00227 , m_pattern(copy_or_null_(m_pattern_, pattern))
00228 , m_flags(flags)
00229 {}
00230 #endif
00231 #if defined(RECLS_API_FTP)
00233 basic_search_sequence(char_type const *host, char_type const *username, char_type const *password, char_type const *directory, char_type const *pattern, recls_uint32_t flags);
00234 #endif
00236 ~basic_search_sequence()
00237 {
00238 #if !defined(RECLS_COMPILER_IS_COMO) && \
00239 !defined(RECLS_COMPILER_IS_GCC) && \
00240 !defined(RECLS_COMPILER_IS_INTEL)
00241 STLSOFT_STATIC_ASSERT(STLSOFT_RAW_OFFSETOF(class_type, m_directory_) < STLSOFT_RAW_OFFSETOF(class_type, m_directory));
00242 STLSOFT_STATIC_ASSERT(STLSOFT_RAW_OFFSETOF(class_type, m_pattern_) < STLSOFT_RAW_OFFSETOF(class_type, m_pattern));
00243 #endif
00244 }
00246
00249 public:
00253 const_iterator begin() const;
00257 const_iterator end() const;
00259
00262 public:
00267 size_type size() const;
00269 recls_bool_t empty() const;
00271 static size_type max_size();
00273
00276 private:
00277 friend class basic_search_sequence_value_type<C, T>;
00278 friend class basic_search_sequence_const_iterator<C, T, value_type>;
00279
00280
00281
00282
00283
00284
00285
00286 template <typename S>
00287 static char_type const *copy_or_null_(file_path_buffer &dest, S const &src)
00288 {
00289
00290
00291 return traits_type::str_copy(&dest[0], stlsoft_ns_qual(c_str_ptr)(src));
00292 }
00293
00294
00295 static char_type const *copy_or_null_(file_path_buffer &dest, char_type const *src)
00296 {
00297 return (NULL == src) ? static_cast<char_type const*>(NULL) : traits_type::str_copy(&dest[0], src);
00298 }
00299
00300
00301 #ifdef STLSOFT_INCL_STLSOFT_UTIL_HPP_NULL
00302 static char_type const *copy_or_null_(file_path_buffer &dest, stlsoft_ns_qual(NULL_v) const &)
00303 {
00304 return NULL;
00305 }
00306 #endif
00307
00308 #if defined(RECLS_API_FTP)
00309 const string_type m_host;
00310 const string_type m_username;
00311 const string_type m_password;
00312 #endif
00313
00314 file_path_buffer m_directory_;
00315 file_path_buffer m_pattern_;
00316 char_type const *const m_directory;
00317 char_type const *const m_pattern;
00318 recls_uint32_t m_flags;
00320
00321
00322 private:
00323 basic_search_sequence(class_type const &);
00324 basic_search_sequence const &operator =(class_type const &);
00325 };
00326
00327
00328
00329
00330
00332 typedef basic_search_sequence<recls_char_a_t, reclstl_traits<recls_char_a_t> > search_sequence_a;
00334 typedef basic_search_sequence<recls_char_w_t, reclstl_traits<recls_char_w_t> > search_sequence_w;
00335
00336 #if defined(RECLS_PLATFORM_IS_WIN32)
00337 typedef basic_search_sequence<TCHAR, reclstl_traits<TCHAR> > search_sequence;
00338 #else
00339 typedef search_sequence_a search_sequence;
00340 #endif
00341
00342
00343
00344
00348 template< typename C
00349 , typename T
00350 >
00351 class basic_search_sequence_value_type
00352 {
00355 public:
00357 typedef C char_type;
00359 typedef T traits_type;
00361 typedef basic_search_sequence_value_type<C, T> class_type;
00363 typedef ss_typename_type_k traits_type::entry_type entry_type;
00365 typedef ss_typename_type_k traits_type::directory_parts_type directory_parts_type;
00367 typedef size_t size_type;
00369
00372 public:
00374 basic_search_sequence_value_type();
00375 basic_search_sequence_value_type(class_type const &rhs);
00376 private:
00377 basic_search_sequence_value_type(entry_type info)
00378 : m_info(info)
00379 {}
00380 public:
00382 ~basic_search_sequence_value_type();
00383
00385 class_type &operator =(class_type const &rhs);
00387
00390 public:
00392 string_t get_path() const;
00394 string_t get_search_relative_path() const;
00396 string_t get_search_directory() const;
00397 #ifdef RECLS_PLATFORM_API_WIN32
00398 char_type get_drive() const;
00399 #endif
00401 string_t get_directory() const;
00403 string_t get_directory_path() const;
00405 string_t get_UNC_drive() const;
00406 #ifndef RECLS_PURE_API
00408 directory_parts_type get_directory_parts() const;
00409 #endif
00411 string_t get_file() const;
00413 string_t get_short_file() const;
00415 string_t get_filename() const;
00417 string_t get_fileext() const;
00418
00419 recls_time_t get_creation_time() const;
00420 recls_time_t get_modification_time() const;
00421 recls_time_t get_last_access_time() const;
00422 recls_time_t get_last_status_change_time() const;
00423
00424 recls_filesize_t get_size() const;
00425
00427 recls_bool_t is_readonly() const;
00429 recls_bool_t is_directory() const;
00431 recls_bool_t is_link() const;
00433 recls_bool_t is_UNC() const;
00434
00435 #ifndef RECLS_PURE_API
00437 char_type const *c_str() const;
00439 size_type get_full_path_length() const;
00440 #endif
00441
00443 entry_type const &get_entry() const;
00445
00447 public:
00448 #ifdef RECLS_STL_METHOD_PROPERTY_SUPPORT
00449 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, path);
00450 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, search_directory);
00451 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, search_relative_path);
00452 #ifdef RECLS_STL_PLATFORM_API_WIN32
00453 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, drive);
00454 #endif
00455 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, directory);
00456 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, directory_path);
00457 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, UNC_drive);
00458 #ifndef RECLS_STL_PURE_API
00459 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, directory_parts);
00460 #endif
00461 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, file);
00462 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, short_file);
00463 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, filename);
00464 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, fileext);
00465 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, creation_time);
00466 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, modification_time);
00467 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, last_access_time);
00468 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, last_status_change_time);
00469 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, size);
00470 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, entry);
00471 union
00472 {
00473 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(string_t, class_type, get_path, path);
00474 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(string_t, class_type, get_search_directory, search_directory);
00475 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(string_t, class_type, get_search_relative_path, search_relative_path);
00476 #ifdef RECLS_STL_PLATFORM_API_WIN32
00477 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(char_type, class_type, get_drive, drive);
00478 #endif
00479 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(string_t, class_type, get_directory, directory);
00480 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(string_t, class_type, get_directory_path, directory_path);
00481 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(string_t, class_type, get_UNC_drive, UNC_drive);
00482 #ifndef RECLS_STL_PURE_API
00483 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(directory_parts_type, class_type, get_directory_parts, directory_parts);
00484 #endif
00485 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(string_t, class_type, get_file, file);
00486 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(string_t, class_type, get_short_file, short_file);
00487 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(string_t, class_type, get_filename, filename);
00488 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(string_t, class_type, get_fileext, fileext);
00489 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(recls_time_t, class_type, get_creation_time, creation_time);
00490 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(recls_time_t, class_type, get_modification_time, modification_time);
00491 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(recls_time_t, class_type, get_last_access_time, last_access_time);
00492 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(recls_time_t, class_type, get_last_status_change_time, last_status_change_time);
00493 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(recls_filesize_t, class_type, get_size, size);
00494 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(entry_type const&, class_type, get_entry, entry);
00495 };
00496 #endif
00498
00500 private:
00501 static string_t get_string_(size_t (RECLS_CALLCONV_DEFAULT *pfn)(recls_info_t, recls_char_t *, size_t), entry_type info)
00502 {
00503 file_path_buffer buffer;
00504 size_t cch = pfn(info, &buffer[0], buffer.size());
00505
00506 return string_t(&buffer[0], cch);
00507 }
00508
00509
00510 private:
00511 friend class basic_search_sequence_const_iterator<C, T, class_type>;
00512
00513 entry_type m_info;
00514 };
00515
00516
00520 template< typename C
00521 , typename T
00522 , typename V
00523 >
00524 class basic_search_sequence_const_iterator
00525 : public stlsoft_ns_qual(iterator_base)<stlsoft_ns_qual_std(input_iterator_tag), V, ptrdiff_t, void, V>
00526 {
00527 public:
00529 typedef C char_type;
00531 typedef T traits_type;
00533 typedef V value_type;
00535 typedef basic_search_sequence_const_iterator<C, T, V> class_type;
00537 typedef ss_typename_type_k traits_type::entry_type entry_type;
00538 private:
00539 typedef basic_search_sequence<C, T> sequence_type;
00540
00541 private:
00542 explicit basic_search_sequence_const_iterator(hrecls_t hSrch)
00543 : m_handle(make_handle_(hSrch))
00544 {}
00545 public:
00547 basic_search_sequence_const_iterator();
00549 basic_search_sequence_const_iterator(class_type const &rhs);
00551 ~basic_search_sequence_const_iterator();
00552
00553
00554 basic_search_sequence_const_iterator &operator =(class_type const &rhs);
00555
00556 public:
00558 class_type &operator ++();
00560 void operator ++(int);
00562 const value_type operator *() const;
00564 bool operator ==(class_type const &rhs) const;
00566 bool operator !=(class_type const &rhs) const;
00567
00568
00569 private:
00570 rss_shared_handle *make_handle_(hrecls_t hSrch);
00571
00572
00573 private:
00574 friend class basic_search_sequence<C, T>;
00575
00576 rss_shared_handle *m_handle;
00577 };
00578
00580
00581
00592 template <typename C, typename T>
00593 inline recls_bool_t is_empty(basic_search_sequence<C, T> const &s)
00594 {
00595 return s.empty();
00596 }
00597
00598 #ifndef RECLS_PURE_API
00599
00610 template <typename C, typename T>
00611 # ifndef RECLS_DOCUMENTATION_SKIP_SECTION
00612 inline ss_typename_type_k basic_search_sequence_value_type<C, T>::char_type const *c_str_ptr(basic_search_sequence_value_type<C, T> const &v)
00613 # else
00614 inline C const *c_str_ptr(basic_search_sequence_value_type<C, T> const &v)
00615 # endif
00616 {
00617 return v.c_str();
00618 }
00619
00620 # ifndef RECLS_DOCUMENTATION_SKIP_SECTION
00621 # ifdef RECLS_CHAR_TYPE_IS_CHAR
00622 template <typename C, typename T>
00623 inline ss_typename_type_k basic_search_sequence_value_type<C, T>::char_type const *c_str_ptr_a(basic_search_sequence_value_type<C, T> const &v)
00624 {
00625 return v.c_str();
00626 }
00627 # endif
00628 # ifdef RECLS_CHAR_TYPE_IS_WCHAR
00629 template <typename C, typename T>
00630 inline ss_typename_type_k basic_search_sequence_value_type<C, T>::char_type const *c_str_ptr_w(basic_search_sequence_value_type<C, T> const &v)
00631 {
00632 return v.c_str();
00633 }
00634 # endif
00635 # endif
00636
00637
00644 template <typename C, typename T>
00645 # ifndef RECLS_DOCUMENTATION_SKIP_SECTION
00646 inline ss_typename_type_k basic_search_sequence_value_type<C, T>::char_type const *c_str_data(basic_search_sequence_value_type<C, T> const &v)
00647 # else
00648 inline C const *c_str_data(basic_search_sequence_value_type<C, T> const &v)
00649 # endif
00650 {
00651 return v.c_str();
00652 }
00653
00654 # ifndef RECLS_DOCUMENTATION_SKIP_SECTION
00655 # ifdef RECLS_CHAR_TYPE_IS_CHAR
00656 template <typename C, typename T>
00657 inline ss_typename_type_k basic_search_sequence_value_type<C, T>::char_type const *c_str_data_a(basic_search_sequence_value_type<C, T> const &v)
00658 {
00659 return v.c_str();
00660 }
00661 # endif
00662 # ifdef RECLS_CHAR_TYPE_IS_WCHAR
00663 template <typename C, typename T>
00664 inline ss_typename_type_k basic_search_sequence_value_type<C, T>::char_type const *c_str_data_w(basic_search_sequence_value_type<C, T> const &v)
00665 {
00666 return v.c_str();
00667 }
00668 # endif
00669 # endif
00670
00671
00678 template <typename C, typename T>
00679 inline size_t c_str_len(basic_search_sequence_value_type<C, T> const &v)
00680 {
00681 return v.get_full_path_length();
00682 }
00683
00684 # ifndef RECLS_DOCUMENTATION_SKIP_SECTION
00685 # ifdef RECLS_CHAR_TYPE_IS_CHAR
00686 template <typename C, typename T>
00687 inline size_t c_str_len_a(basic_search_sequence_value_type<C, T> const &v)
00688 {
00689 return v.get_full_path_length();
00690 }
00691 # endif
00692 # ifdef RECLS_CHAR_TYPE_IS_WCHAR
00693 template <typename C, typename T>
00694 inline size_t c_str_len_w(basic_search_sequence_value_type<C, T> const &v)
00695 {
00696 return v.get_full_path_length();
00697 }
00698 # endif
00699 # endif
00700
00701 #endif
00702
00704
00705
00706 # if ( !defined(STLSOFT_COMPILER_IS_MSVC) && \
00707 !defined(STLSOFT_COMPILER_IS_UNKNOWN)) || \
00708 !defined(_MSC_VER) || \
00709 _MSC_VER >= 1310
00710
00711 template< typename S
00712 , typename C
00713 , typename T
00714 >
00715 inline S &operator <<(S &s, basic_search_sequence_value_type<C, T> const &v)
00716 {
00717 #ifdef RECLS_PURE_API
00718 s << v.c_str();
00719 #else
00720 s << stlsoft_ns_qual(c_str_ptr)(v.get_path());
00721 #endif
00722
00723 return s;
00724 }
00725
00726 #endif
00727
00729
00730
00731 #ifndef RECLS_DOCUMENTATION_SKIP_SECTION
00732
00733
00734
00735
00736
00737 template <typename C, typename T>
00738 inline basic_search_sequence<C, T>::basic_search_sequence(char_type const *pattern, recls_uint32_t flags)
00739 : m_directory(copy_or_null_(m_directory_, ""))
00740 , m_pattern(copy_or_null_(m_pattern_, pattern))
00741 , m_flags(flags)
00742 {}
00743
00744 template <typename C, typename T>
00745 inline basic_search_sequence<C, T>::basic_search_sequence(char_type const *directory, char_type const *pattern, recls_uint32_t flags)
00746 : m_directory(copy_or_null_(m_directory_, directory))
00747 , m_pattern(copy_or_null_(m_pattern_, pattern))
00748 , m_flags(flags)
00749 {}
00750
00751 #if defined(RECLS_API_FTP)
00752 template <typename C, typename T>
00753 inline basic_search_sequence<C, T>::basic_search_sequence(char_type const *host, char_type const *username, char_type const *password, char_type const *directory, char_type const *pattern, recls_uint32_t flags)
00754 : m_host(host)
00755 , m_username(username)
00756 , m_password(password)
00757 , m_directory(copy_or_null_(m_directory_, directory))
00758 , m_pattern(copy_or_null_(m_pattern_, pattern))
00759 , m_flags(flags)
00760 {
00761 RECLS_MESSAGE_ASSERT("Must specify a hostname if using FTP", (NULL == username && NULL == password) || NULL != host);
00762 }
00763 #endif
00764
00765
00766 template <typename C, typename T>
00767 inline ss_typename_type_k basic_search_sequence<C, T>::const_iterator basic_search_sequence<C, T>::begin() const
00768 {
00769 hrecls_t hSrch;
00770 recls_rc_t rc;
00771
00772 #if defined(RECLS_API_FTP)
00773 if(m_host.empty())
00774 {
00775 #endif
00776 rc = traits_type::Search(m_directory, m_pattern, m_flags, &hSrch);
00777 #if defined(RECLS_API_FTP)
00778 }
00779 else
00780 {
00781 rc = traits_type::SearchFtp(m_host.c_str(), m_username.c_str(), m_password.c_str(), m_directory, m_pattern, m_flags, &hSrch);
00782 }
00783 #endif
00784
00785 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
00786 if( RECLS_FAILED(rc) &&
00787 RECLS_RC_NO_MORE_DATA != rc)
00788 {
00789 throw recls_exception(rc);
00790 }
00791 #endif
00792
00793 return const_iterator(hSrch);
00794 }
00795
00796 template <typename C, typename T>
00797 inline ss_typename_type_k basic_search_sequence<C, T>::const_iterator basic_search_sequence<C, T>::end() const
00798 {
00799 return const_iterator();
00800 }
00801
00802
00803 template <typename C, typename T>
00804 inline ss_typename_type_k basic_search_sequence<C, T>::size_type basic_search_sequence<C, T>::size() const
00805 {
00806 const_iterator b = begin();
00807 const_iterator e = end();
00808 size_type c = 0;
00809
00810 for(; b != e; ++b)
00811 {
00812 ++c;
00813 }
00814
00815 return c;
00816 }
00817
00818 template <typename C, typename T>
00819 inline recls_bool_t basic_search_sequence<C, T>::empty() const
00820 {
00821 return begin() == end();
00822 }
00823
00824 template <typename C, typename T>
00825 inline ss_typename_type_k basic_search_sequence<C, T>::size_type basic_search_sequence<C, T>::max_size()
00826 {
00827 return static_cast<size_type>(-1);
00828 }
00829
00830
00831
00832
00833 template <typename C, typename T>
00834 inline basic_search_sequence_value_type<C, T>::basic_search_sequence_value_type()
00835 : m_info(NULL)
00836 {}
00837
00838 template <typename C, typename T>
00839 inline basic_search_sequence_value_type<C, T>::basic_search_sequence_value_type(ss_typename_type_k basic_search_sequence_value_type<C, T>::class_type const &rhs)
00840 : m_info(traits_type::CopyDetails(rhs.m_info))
00841 {}
00842
00843 template <typename C, typename T>
00844 inline basic_search_sequence_value_type<C, T>::~basic_search_sequence_value_type()
00845 {
00846 if(NULL != m_info)
00847 {
00848 traits_type::CloseDetails(m_info);
00849 }
00850 }
00851
00852 template <typename C, typename T>
00853 inline ss_typename_type_k basic_search_sequence_value_type<C, T>::class_type &basic_search_sequence_value_type<C, T>::operator =(ss_typename_type_k basic_search_sequence_value_type<C, T>::class_type const &rhs)
00854 {
00855 if(NULL != m_info)
00856 {
00857 traits_type::CloseDetails(m_info);
00858 }
00859
00860 m_info = traits_type::CopyDetails(rhs.m_info);
00861
00862 return *this;
00863 }
00864
00865 template <typename C, typename T>
00866 inline string_t basic_search_sequence_value_type<C, T>::get_path() const
00867 {
00868 RECLS_ASSERT(NULL != m_info);
00869
00870 #ifdef RECLS_PURE_API
00871 return get_string_(Recls_GetPathProperty, m_info);
00872 #else
00873 return string_t(m_info->path.begin, m_info->path.end);
00874 #endif
00875 }
00876
00877 template <typename C, typename T>
00878 inline string_t basic_search_sequence_value_type<C, T>::get_search_directory() const
00879 {
00880 RECLS_ASSERT(NULL != m_info);
00881
00882 #ifdef RECLS_PURE_API
00883 return get_string_(Recls_GetSearchDirectoryProperty, m_info);
00884 #else
00885 return string_t(m_info->searchDirectory.begin, m_info->searchDirectory.end);
00886 #endif
00887 }
00888
00889 template <typename C, typename T>
00890 inline string_t basic_search_sequence_value_type<C, T>::get_search_relative_path() const
00891 {
00892 RECLS_ASSERT(NULL != m_info);
00893
00894 #ifdef RECLS_PURE_API
00895 return get_string_(Recls_GetSearchRelativePatahProperty, m_info);
00896 #else
00897 return string_t(m_info->searchRelativePath.begin, m_info->searchRelativePath.end);
00898 #endif
00899 }
00900
00901 #ifdef RECLS_PLATFORM_API_WIN32
00902 template <typename C, typename T>
00903 inline ss_typename_type_k basic_search_sequence_value_type<C, T>::char_type basic_search_sequence_value_type<C, T>::get_drive() const
00904 {
00905 char_type chDrive;
00906
00907 return (Recls_GetDriveProperty(m_info, &chDrive), chDrive);
00908 }
00909 #endif
00910
00911 template <typename C, typename T>
00912 inline string_t basic_search_sequence_value_type<C, T>::get_directory() const
00913 {
00914 RECLS_ASSERT(NULL != m_info);
00915
00916 #ifdef RECLS_PURE_API
00917 return get_string_(Recls_GetDirectoryProperty, m_info);
00918 #else
00919 return string_t(m_info->directory.begin, m_info->directory.end);
00920 #endif
00921 }
00922
00923 template <typename C, typename T>
00924 inline string_t basic_search_sequence_value_type<C, T>::get_directory_path() const
00925 {
00926 RECLS_ASSERT(NULL != m_info);
00927
00928 #ifdef RECLS_PURE_API
00929 return get_string_(Recls_GetDirectoryPathProperty, m_info);
00930 #else
00931 return string_t(m_info->path.begin, m_info->directory.end);
00932 #endif
00933 }
00934
00935 template <typename C, typename T>
00936 inline string_t basic_search_sequence_value_type<C, T>::get_UNC_drive() const
00937 {
00938 RECLS_ASSERT(NULL != m_info);
00939
00940 #if 0
00941 if(!is_UNC())
00942 {
00943 return string_t();
00944 }
00945 else
00946 {
00947 #ifdef RECLS_PURE_API
00948 string_t directoryPath = get_directory_path();
00949 size_t directoryLen = Recls_GetDirectoryProperty(m_info, NULL, 0);
00950
00951 return string_t(directoryPath, 0, directoryPath.length() - directoryLen);
00952 #else
00953 return string_t(m_info->path.begin, m_info->directory.begin);
00954 #endif
00955 }
00956 #else
00957 # ifdef RECLS_PURE_API
00958 return get_string_(Recls_GetUNCDriveProperty, m_info);
00959 # else
00960 return string_t(m_info->path.begin, m_info->directory.begin);
00961 # endif
00962 #endif
00963 }
00964
00965 #ifndef RECLS_PURE_API
00966 template <typename C, typename T>
00967 inline ss_typename_type_k basic_search_sequence_value_type<C, T>::directory_parts_type basic_search_sequence_value_type<C, T>::get_directory_parts() const
00968 {
00969 RECLS_ASSERT(NULL != m_info);
00970
00971 return directory_parts_type(m_info->directoryParts.begin, m_info->directoryParts.end);
00972 }
00973 #endif
00974
00975 template <typename C, typename T>
00976 inline string_t basic_search_sequence_value_type<C, T>::get_file() const
00977 {
00978 RECLS_ASSERT(NULL != m_info);
00979
00980 #ifdef RECLS_PURE_API
00981 return get_string_(Recls_GetFileProperty, m_info);
00982 #else
00983 return string_t(m_info->fileName.begin, m_info->fileExt.end);
00984 #endif
00985 }
00986
00987 template <typename C, typename T>
00988 inline string_t basic_search_sequence_value_type<C, T>::get_short_file() const
00989 {
00990 RECLS_ASSERT(NULL != m_info);
00991
00992 return get_string_(Recls_GetShortFileProperty, m_info);
00993 }
00994
00995 template <typename C, typename T>
00996 inline string_t basic_search_sequence_value_type<C, T>::get_filename() const
00997 {
00998 RECLS_ASSERT(NULL != m_info);
00999
01000 #ifdef RECLS_PURE_API
01001 return get_string_(Recls_GetFileNameProperty, m_info);
01002 #else
01003 return string_t(m_info->fileName.begin, m_info->fileName.end);
01004 #endif
01005 }
01006
01007 template <typename C, typename T>
01008 inline string_t basic_search_sequence_value_type<C, T>::get_fileext() const
01009 {
01010 RECLS_ASSERT(NULL != m_info);
01011
01012 #ifdef RECLS_PURE_API
01013 return get_string_(Recls_GetFileExtProperty, m_info);
01014 #else
01015 return string_t(m_info->fileExt.begin, m_info->fileExt.end);
01016 #endif
01017 }
01018
01019 template <typename C, typename T>
01020 inline recls_time_t basic_search_sequence_value_type<C, T>::get_creation_time() const
01021 {
01022 RECLS_ASSERT(NULL != m_info);
01023
01024 return Recls_GetCreationTime(m_info);
01025 }
01026
01027 template <typename C, typename T>
01028 inline recls_time_t basic_search_sequence_value_type<C, T>::get_modification_time() const
01029 {
01030 RECLS_ASSERT(NULL != m_info);
01031
01032 return Recls_GetModificationTime(m_info);
01033 }
01034
01035 template <typename C, typename T>
01036 inline recls_time_t basic_search_sequence_value_type<C, T>::get_last_access_time() const
01037 {
01038 RECLS_ASSERT(NULL != m_info);
01039
01040 return Recls_GetLastAccessTime(m_info);
01041 }
01042
01043 template <typename C, typename T>
01044 inline recls_time_t basic_search_sequence_value_type<C, T>::get_last_status_change_time() const
01045 {
01046 RECLS_ASSERT(NULL != m_info);
01047
01048 return Recls_GetLastStatusChangeTime(m_info);
01049 }
01050
01051 template <typename C, typename T>
01052 inline recls_filesize_t basic_search_sequence_value_type<C, T>::get_size() const
01053 {
01054 RECLS_ASSERT(NULL != m_info);
01055
01056 #ifdef RECLS_PURE_API
01057 recls_filesize_t size;
01058
01059 return (Recls_GetSizeProperty(m_info, &size), size);
01060 #else
01061 return m_info->size;
01062 #endif
01063 }
01064
01065 template <typename C, typename T>
01066 inline recls_bool_t basic_search_sequence_value_type<C, T>::is_readonly() const
01067 {
01068 RECLS_ASSERT(NULL != m_info);
01069
01070 return Recls_IsFileReadOnly(m_info);
01071 }
01072
01073 template <typename C, typename T>
01074 inline recls_bool_t basic_search_sequence_value_type<C, T>::is_directory() const
01075 {
01076 RECLS_ASSERT(NULL != m_info);
01077
01078 return Recls_IsFileDirectory(m_info);
01079 }
01080
01081 template <typename C, typename T>
01082 inline recls_bool_t basic_search_sequence_value_type<C, T>::is_link() const
01083 {
01084 RECLS_ASSERT(NULL != m_info);
01085
01086 return Recls_IsFileLink(m_info);
01087 }
01088
01089 template <typename C, typename T>
01090 inline recls_bool_t basic_search_sequence_value_type<C, T>::is_UNC() const
01091 {
01092 RECLS_ASSERT(NULL != m_info);
01093
01094 return Recls_IsFileUNC(m_info);
01095 }
01096
01097 #ifndef RECLS_PURE_API
01098 template <typename C, typename T>
01099 inline ss_typename_type_k basic_search_sequence_value_type<C, T>::char_type const * basic_search_sequence_value_type<C, T>::c_str() const
01100 {
01101 RECLS_ASSERT(NULL != m_info);
01102
01103 return m_info->path.begin;
01104 }
01105
01106 template <typename C, typename T>
01107 inline ss_typename_type_k basic_search_sequence_value_type<C, T>::size_type basic_search_sequence_value_type<C, T>::get_full_path_length() const
01108 {
01109 return static_cast<size_type>(m_info->path.end - m_info->path.begin);
01110 }
01111 #endif
01112
01113 template <typename C, typename T>
01114 inline ss_typename_type_k basic_search_sequence_value_type<C, T>::entry_type const &basic_search_sequence_value_type<C, T>::get_entry() const
01115 {
01116 return m_info;
01117 }
01118
01119
01120
01121 template <typename C, typename T, typename V>
01122 inline rss_shared_handle *basic_search_sequence_const_iterator<C, T, V>::make_handle_(hrecls_t hSrch)
01123 {
01124 return (NULL != hSrch) ? new rss_shared_handle(hSrch) : static_cast<rss_shared_handle*>(NULL);
01125 }
01126
01127 template <typename C, typename T, typename V>
01128 inline basic_search_sequence_const_iterator<C, T, V>::basic_search_sequence_const_iterator()
01129 : m_handle(NULL)
01130 {}
01131
01132 template <typename C, typename T, typename V>
01133 inline basic_search_sequence_const_iterator<C, T, V>::basic_search_sequence_const_iterator(class_type const &rhs)
01134 : m_handle(rhs.m_handle)
01135 {
01136 if(NULL != m_handle)
01137 {
01138 ++m_handle->cRefs;
01139 }
01140 }
01141
01142 template <typename C, typename T, typename V>
01143 inline ss_typename_type_k basic_search_sequence_const_iterator<C, T, V>::class_type &basic_search_sequence_const_iterator<C, T, V>::operator =(typename basic_search_sequence_const_iterator<C, T, V>::class_type const &rhs)
01144 {
01145 if(NULL != m_handle)
01146 {
01147 m_handle->Release();
01148 }
01149
01150 m_handle = rhs.m_handle;
01151
01152 if(NULL != m_handle)
01153 {
01154 ++m_handle->cRefs;
01155 }
01156
01157 return *this;
01158 }
01159
01160 template <typename C, typename T, typename V>
01161 inline basic_search_sequence_const_iterator<C, T, V>::~basic_search_sequence_const_iterator()
01162 {
01163 if(NULL != m_handle)
01164 {
01165 m_handle->Release();
01166 }
01167 }
01168
01169 template <typename C, typename T, typename V>
01170 inline ss_typename_type_k basic_search_sequence_const_iterator<C, T, V>::class_type &basic_search_sequence_const_iterator<C, T, V>::operator ++()
01171 {
01172 #if !defined(STLSOFT_COMPILER_IS_GCC) // GCC on Mac has a cow here
01173 RECLS_MESSAGE_ASSERT("Attempting to increment invalid iterator", NULL != m_handle);
01174 #endif
01175
01176 if(RECLS_FAILED(Recls_GetNext(m_handle->hSrch)))
01177 {
01178 m_handle->Release();
01179
01180 m_handle = NULL;
01181 }
01182
01183 return *this;
01184 }
01185
01186 template <typename C, typename T, typename V>
01187 inline void basic_search_sequence_const_iterator<C, T, V>::operator ++(int)
01188 {
01189 operator ++();
01190 }
01191
01192 template <typename C, typename T, typename V>
01193 inline const ss_typename_type_k basic_search_sequence_const_iterator<C, T, V>::value_type basic_search_sequence_const_iterator<C, T, V>::operator *() const
01194 {
01195 entry_type info;
01196
01197 #if !defined(STLSOFT_COMPILER_IS_GCC) // GCC on Mac has a cow here
01198 RECLS_MESSAGE_ASSERT("Attempting to dereference invalid iterator", NULL != m_handle);
01199 #endif
01200
01201 if( m_handle->hSrch != NULL &&
01202 RECLS_SUCCEEDED(traits_type::GetDetails(m_handle->hSrch, &info)))
01203 {
01204 return value_type(info);
01205 }
01206 else
01207 {
01208 RECLS_MESSAGE_ASSERT("Dereferencing end()-valued iterator", 0);
01209
01210 return value_type();
01211 }
01212 }
01213
01214 template <typename C, typename T, typename V>
01215 inline bool basic_search_sequence_const_iterator<C, T, V>::operator ==(class_type const &rhs) const
01216 {
01217 return (m_handle == NULL) && (rhs.m_handle == NULL);
01218 }
01219
01220 template <typename C, typename T, typename V>
01221 inline bool basic_search_sequence_const_iterator<C, T, V>::operator !=(class_type const &rhs) const
01222 {
01223 return ! operator ==(rhs);
01224 }
01225
01226 #endif
01227
01228
01229
01230 #if !defined(RECLS_NO_NAMESPACE)
01231 }
01232 }
01233
01234
01235 # if ( defined(STLSOFT_COMPILER_IS_MSVC) || \
01236 defined(STLSOFT_COMPILER_IS_UNKNOWN)) && \
01237 defined(_MSC_VER) && \
01238 _MSC_VER < 1310
01239
01240 template< ss_typename_param_k C
01241 , ss_typename_param_k T
01242 >
01243 inline std::basic_ostream<C>& operator <<(std::basic_ostream<C>& s, ::recls::stl::basic_search_sequence_value_type<C, T> const& v)
01244 {
01245 #ifdef RECLS_PURE_API
01246 s << v.c_str();
01247 #else
01248 s << stlsoft_ns_qual(c_str_ptr)(v.get_path());
01249 #endif
01250
01251 return s;
01252 }
01253
01254 # endif
01255
01256
01257 namespace stlsoft
01258 {
01259 using recls::stl::is_empty;
01260 #ifndef RECLS_PURE_API
01261 using recls::stl::c_str_data;
01262 using recls::stl::c_str_len;
01263 using recls::stl::c_str_ptr;
01264 #ifdef RECLS_CHAR_TYPE_IS_CHAR
01265 using recls::stl::c_str_data_a;
01266 using recls::stl::c_str_len_a;
01267 using recls::stl::c_str_ptr_a;
01268 #endif
01269 # ifdef RECLS_CHAR_TYPE_IS_WCHAR
01270 using recls::stl::c_str_data_w;
01271 using recls::stl::c_str_len_w;
01272 using recls::stl::c_str_ptr_w;
01273 # endif
01274 #endif
01275
01276 }
01277 #endif
01278
01279
01280
01281 #endif
01282
01283