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