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 5
00049 # define RECLS_VER_RECLSTL_STL_HPP_SEARCH_SEQUENCE_EDIT 73
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 _MSC_VER >= 1310
00708
00709 template< typename S
00710 , typename C
00711 , typename T
00712 >
00713 inline S &operator <<(S &s, basic_search_sequence_value_type<C, T> const &v)
00714 {
00715 #ifdef RECLS_PURE_API
00716 s << v.c_str();
00717 #else
00718 s << stlsoft_ns_qual(c_str_ptr)(v.get_path());
00719 #endif
00720
00721 return s;
00722 }
00723
00724 #endif
00725
00727
00728
00729 #ifndef RECLS_DOCUMENTATION_SKIP_SECTION
00730
00731
00732
00733
00734
00735 template <typename C, typename T>
00736 inline basic_search_sequence<C, T>::basic_search_sequence(char_type const *pattern, recls_uint32_t flags)
00737 : m_directory(copy_or_null_(m_directory_, ""))
00738 , m_pattern(copy_or_null_(m_pattern_, pattern))
00739 , m_flags(flags)
00740 {}
00741
00742 template <typename C, typename T>
00743 inline basic_search_sequence<C, T>::basic_search_sequence(char_type const *directory, char_type const *pattern, recls_uint32_t flags)
00744 : m_directory(copy_or_null_(m_directory_, directory))
00745 , m_pattern(copy_or_null_(m_pattern_, pattern))
00746 , m_flags(flags)
00747 {}
00748
00749 #if defined(RECLS_API_FTP)
00750 template <typename C, typename T>
00751 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)
00752 : m_host(host)
00753 , m_username(username)
00754 , m_password(password)
00755 , m_directory(copy_or_null_(m_directory_, directory))
00756 , m_pattern(copy_or_null_(m_pattern_, pattern))
00757 , m_flags(flags)
00758 {
00759 RECLS_MESSAGE_ASSERT("Must specify a hostname if using FTP", (NULL == username && NULL == password) || NULL != host);
00760 }
00761 #endif
00762
00763
00764 template <typename C, typename T>
00765 inline ss_typename_type_k basic_search_sequence<C, T>::const_iterator basic_search_sequence<C, T>::begin() const
00766 {
00767 hrecls_t hSrch;
00768 recls_rc_t rc;
00769
00770 #if defined(RECLS_API_FTP)
00771 if(m_host.empty())
00772 {
00773 #endif
00774 rc = traits_type::Search(m_directory, m_pattern, m_flags, &hSrch);
00775 #if defined(RECLS_API_FTP)
00776 }
00777 else
00778 {
00779 rc = traits_type::SearchFtp(m_host.c_str(), m_username.c_str(), m_password.c_str(), m_directory, m_pattern, m_flags, &hSrch);
00780 }
00781 #endif
00782
00783 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
00784 if( RECLS_FAILED(rc) &&
00785 RECLS_RC_NO_MORE_DATA != rc)
00786 {
00787 throw recls_exception(rc);
00788 }
00789 #endif
00790
00791 return const_iterator(hSrch);
00792 }
00793
00794 template <typename C, typename T>
00795 inline ss_typename_type_k basic_search_sequence<C, T>::const_iterator basic_search_sequence<C, T>::end() const
00796 {
00797 return const_iterator();
00798 }
00799
00800
00801 template <typename C, typename T>
00802 inline ss_typename_type_k basic_search_sequence<C, T>::size_type basic_search_sequence<C, T>::size() const
00803 {
00804 const_iterator b = begin();
00805 const_iterator e = end();
00806 size_type c = 0;
00807
00808 for(; b != e; ++b)
00809 {
00810 ++c;
00811 }
00812
00813 return c;
00814 }
00815
00816 template <typename C, typename T>
00817 inline recls_bool_t basic_search_sequence<C, T>::empty() const
00818 {
00819 return begin() == end();
00820 }
00821
00822 template <typename C, typename T>
00823 inline ss_typename_type_k basic_search_sequence<C, T>::size_type basic_search_sequence<C, T>::max_size()
00824 {
00825 return static_cast<size_type>(-1);
00826 }
00827
00828
00829
00830
00831 template <typename C, typename T>
00832 inline basic_search_sequence_value_type<C, T>::basic_search_sequence_value_type()
00833 : m_info(NULL)
00834 {}
00835
00836 template <typename C, typename T>
00837 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)
00838 : m_info(traits_type::CopyDetails(rhs.m_info))
00839 {}
00840
00841 template <typename C, typename T>
00842 inline basic_search_sequence_value_type<C, T>::~basic_search_sequence_value_type()
00843 {
00844 if(NULL != m_info)
00845 {
00846 traits_type::CloseDetails(m_info);
00847 }
00848 }
00849
00850 template <typename C, typename T>
00851 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)
00852 {
00853 if(NULL != m_info)
00854 {
00855 traits_type::CloseDetails(m_info);
00856 }
00857
00858 m_info = traits_type::CopyDetails(rhs.m_info);
00859
00860 return *this;
00861 }
00862
00863 template <typename C, typename T>
00864 inline string_t basic_search_sequence_value_type<C, T>::get_path() const
00865 {
00866 RECLS_ASSERT(NULL != m_info);
00867
00868 #ifdef RECLS_PURE_API
00869 return get_string_(Recls_GetPathProperty, m_info);
00870 #else
00871 return string_t(m_info->path.begin, m_info->path.end);
00872 #endif
00873 }
00874
00875 template <typename C, typename T>
00876 inline string_t basic_search_sequence_value_type<C, T>::get_search_directory() const
00877 {
00878 RECLS_ASSERT(NULL != m_info);
00879
00880 #ifdef RECLS_PURE_API
00881 return get_string_(Recls_GetSearchDirectoryProperty, m_info);
00882 #else
00883 return string_t(m_info->searchDirectory.begin, m_info->searchDirectory.end);
00884 #endif
00885 }
00886
00887 template <typename C, typename T>
00888 inline string_t basic_search_sequence_value_type<C, T>::get_search_relative_path() const
00889 {
00890 RECLS_ASSERT(NULL != m_info);
00891
00892 #ifdef RECLS_PURE_API
00893 return get_string_(Recls_GetSearchRelativePatahProperty, m_info);
00894 #else
00895 return string_t(m_info->searchRelativePath.begin, m_info->searchRelativePath.end);
00896 #endif
00897 }
00898
00899 #ifdef RECLS_PLATFORM_API_WIN32
00900 template <typename C, typename T>
00901 inline ss_typename_type_k basic_search_sequence_value_type<C, T>::char_type basic_search_sequence_value_type<C, T>::get_drive() const
00902 {
00903 char_type chDrive;
00904
00905 return (Recls_GetDriveProperty(m_info, &chDrive), chDrive);
00906 }
00907 #endif
00908
00909 template <typename C, typename T>
00910 inline string_t basic_search_sequence_value_type<C, T>::get_directory() const
00911 {
00912 RECLS_ASSERT(NULL != m_info);
00913
00914 #ifdef RECLS_PURE_API
00915 return get_string_(Recls_GetDirectoryProperty, m_info);
00916 #else
00917 return string_t(m_info->directory.begin, m_info->directory.end);
00918 #endif
00919 }
00920
00921 template <typename C, typename T>
00922 inline string_t basic_search_sequence_value_type<C, T>::get_directory_path() const
00923 {
00924 RECLS_ASSERT(NULL != m_info);
00925
00926 #ifdef RECLS_PURE_API
00927 return get_string_(Recls_GetDirectoryPathProperty, m_info);
00928 #else
00929 return string_t(m_info->path.begin, m_info->directory.end);
00930 #endif
00931 }
00932
00933 template <typename C, typename T>
00934 inline string_t basic_search_sequence_value_type<C, T>::get_UNC_drive() const
00935 {
00936 RECLS_ASSERT(NULL != m_info);
00937
00938 #if 0
00939 if(!is_UNC())
00940 {
00941 return string_t();
00942 }
00943 else
00944 {
00945 #ifdef RECLS_PURE_API
00946 string_t directoryPath = get_directory_path();
00947 size_t directoryLen = Recls_GetDirectoryProperty(m_info, NULL, 0);
00948
00949 return string_t(directoryPath, 0, directoryPath.length() - directoryLen);
00950 #else
00951 return string_t(m_info->path.begin, m_info->directory.begin);
00952 #endif
00953 }
00954 #else
00955 # ifdef RECLS_PURE_API
00956 return get_string_(Recls_GetUNCDriveProperty, m_info);
00957 # else
00958 return string_t(m_info->path.begin, m_info->directory.begin);
00959 # endif
00960 #endif
00961 }
00962
00963 #ifndef RECLS_PURE_API
00964 template <typename C, typename T>
00965 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
00966 {
00967 RECLS_ASSERT(NULL != m_info);
00968
00969 return directory_parts_type(m_info->directoryParts.begin, m_info->directoryParts.end);
00970 }
00971 #endif
00972
00973 template <typename C, typename T>
00974 inline string_t basic_search_sequence_value_type<C, T>::get_file() const
00975 {
00976 RECLS_ASSERT(NULL != m_info);
00977
00978 #ifdef RECLS_PURE_API
00979 return get_string_(Recls_GetFileProperty, m_info);
00980 #else
00981 return string_t(m_info->fileName.begin, m_info->fileExt.end);
00982 #endif
00983 }
00984
00985 template <typename C, typename T>
00986 inline string_t basic_search_sequence_value_type<C, T>::get_short_file() const
00987 {
00988 RECLS_ASSERT(NULL != m_info);
00989
00990 return get_string_(Recls_GetShortFileProperty, m_info);
00991 }
00992
00993 template <typename C, typename T>
00994 inline string_t basic_search_sequence_value_type<C, T>::get_filename() const
00995 {
00996 RECLS_ASSERT(NULL != m_info);
00997
00998 #ifdef RECLS_PURE_API
00999 return get_string_(Recls_GetFileNameProperty, m_info);
01000 #else
01001 return string_t(m_info->fileName.begin, m_info->fileName.end);
01002 #endif
01003 }
01004
01005 template <typename C, typename T>
01006 inline string_t basic_search_sequence_value_type<C, T>::get_fileext() const
01007 {
01008 RECLS_ASSERT(NULL != m_info);
01009
01010 #ifdef RECLS_PURE_API
01011 return get_string_(Recls_GetFileExtProperty, m_info);
01012 #else
01013 return string_t(m_info->fileExt.begin, m_info->fileExt.end);
01014 #endif
01015 }
01016
01017 template <typename C, typename T>
01018 inline recls_time_t basic_search_sequence_value_type<C, T>::get_creation_time() const
01019 {
01020 RECLS_ASSERT(NULL != m_info);
01021
01022 return Recls_GetCreationTime(m_info);
01023 }
01024
01025 template <typename C, typename T>
01026 inline recls_time_t basic_search_sequence_value_type<C, T>::get_modification_time() const
01027 {
01028 RECLS_ASSERT(NULL != m_info);
01029
01030 return Recls_GetModificationTime(m_info);
01031 }
01032
01033 template <typename C, typename T>
01034 inline recls_time_t basic_search_sequence_value_type<C, T>::get_last_access_time() const
01035 {
01036 RECLS_ASSERT(NULL != m_info);
01037
01038 return Recls_GetLastAccessTime(m_info);
01039 }
01040
01041 template <typename C, typename T>
01042 inline recls_time_t basic_search_sequence_value_type<C, T>::get_last_status_change_time() const
01043 {
01044 RECLS_ASSERT(NULL != m_info);
01045
01046 return Recls_GetLastStatusChangeTime(m_info);
01047 }
01048
01049 template <typename C, typename T>
01050 inline recls_filesize_t basic_search_sequence_value_type<C, T>::get_size() const
01051 {
01052 RECLS_ASSERT(NULL != m_info);
01053
01054 #ifdef RECLS_PURE_API
01055 recls_filesize_t size;
01056
01057 return (Recls_GetSizeProperty(m_info, &size), size);
01058 #else
01059 return m_info->size;
01060 #endif
01061 }
01062
01063 template <typename C, typename T>
01064 inline recls_bool_t basic_search_sequence_value_type<C, T>::is_readonly() const
01065 {
01066 RECLS_ASSERT(NULL != m_info);
01067
01068 return Recls_IsFileReadOnly(m_info);
01069 }
01070
01071 template <typename C, typename T>
01072 inline recls_bool_t basic_search_sequence_value_type<C, T>::is_directory() const
01073 {
01074 RECLS_ASSERT(NULL != m_info);
01075
01076 return Recls_IsFileDirectory(m_info);
01077 }
01078
01079 template <typename C, typename T>
01080 inline recls_bool_t basic_search_sequence_value_type<C, T>::is_link() const
01081 {
01082 RECLS_ASSERT(NULL != m_info);
01083
01084 return Recls_IsFileLink(m_info);
01085 }
01086
01087 template <typename C, typename T>
01088 inline recls_bool_t basic_search_sequence_value_type<C, T>::is_UNC() const
01089 {
01090 RECLS_ASSERT(NULL != m_info);
01091
01092 return Recls_IsFileUNC(m_info);
01093 }
01094
01095 #ifndef RECLS_PURE_API
01096 template <typename C, typename T>
01097 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
01098 {
01099 RECLS_ASSERT(NULL != m_info);
01100
01101 return m_info->path.begin;
01102 }
01103
01104 template <typename C, typename T>
01105 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
01106 {
01107 return static_cast<size_type>(m_info->path.end - m_info->path.begin);
01108 }
01109 #endif
01110
01111 template <typename C, typename T>
01112 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
01113 {
01114 return m_info;
01115 }
01116
01117
01118
01119 template <typename C, typename T, typename V>
01120 inline rss_shared_handle *basic_search_sequence_const_iterator<C, T, V>::make_handle_(hrecls_t hSrch)
01121 {
01122 return (NULL != hSrch) ? new rss_shared_handle(hSrch) : static_cast<rss_shared_handle*>(NULL);
01123 }
01124
01125 template <typename C, typename T, typename V>
01126 inline basic_search_sequence_const_iterator<C, T, V>::basic_search_sequence_const_iterator()
01127 : m_handle(NULL)
01128 {}
01129
01130 template <typename C, typename T, typename V>
01131 inline basic_search_sequence_const_iterator<C, T, V>::basic_search_sequence_const_iterator(class_type const &rhs)
01132 : m_handle(rhs.m_handle)
01133 {
01134 if(NULL != m_handle)
01135 {
01136 ++m_handle->cRefs;
01137 }
01138 }
01139
01140 template <typename C, typename T, typename V>
01141 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)
01142 {
01143 if(NULL != m_handle)
01144 {
01145 m_handle->Release();
01146 }
01147
01148 m_handle = rhs.m_handle;
01149
01150 if(NULL != m_handle)
01151 {
01152 ++m_handle->cRefs;
01153 }
01154
01155 return *this;
01156 }
01157
01158 template <typename C, typename T, typename V>
01159 inline basic_search_sequence_const_iterator<C, T, V>::~basic_search_sequence_const_iterator()
01160 {
01161 if(NULL != m_handle)
01162 {
01163 m_handle->Release();
01164 }
01165 }
01166
01167 template <typename C, typename T, typename V>
01168 inline ss_typename_type_k basic_search_sequence_const_iterator<C, T, V>::class_type &basic_search_sequence_const_iterator<C, T, V>::operator ++()
01169 {
01170 #if !defined(STLSOFT_COMPILER_IS_GCC) // GCC on Mac has a cow here
01171 RECLS_MESSAGE_ASSERT("Attempting to increment invalid iterator", NULL != m_handle);
01172 #endif
01173
01174 if(RECLS_FAILED(Recls_GetNext(m_handle->hSrch)))
01175 {
01176 m_handle->Release();
01177
01178 m_handle = NULL;
01179 }
01180
01181 return *this;
01182 }
01183
01184 template <typename C, typename T, typename V>
01185 inline void basic_search_sequence_const_iterator<C, T, V>::operator ++(int)
01186 {
01187 operator ++();
01188 }
01189
01190 template <typename C, typename T, typename V>
01191 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
01192 {
01193 entry_type info;
01194
01195 #if !defined(STLSOFT_COMPILER_IS_GCC) // GCC on Mac has a cow here
01196 RECLS_MESSAGE_ASSERT("Attempting to dereference invalid iterator", NULL != m_handle);
01197 #endif
01198
01199 if( m_handle->hSrch != NULL &&
01200 RECLS_SUCCEEDED(traits_type::GetDetails(m_handle->hSrch, &info)))
01201 {
01202 return value_type(info);
01203 }
01204 else
01205 {
01206 RECLS_MESSAGE_ASSERT("Dereferencing end()-valued iterator", 0);
01207
01208 return value_type();
01209 }
01210 }
01211
01212 template <typename C, typename T, typename V>
01213 inline bool basic_search_sequence_const_iterator<C, T, V>::operator ==(class_type const &rhs) const
01214 {
01215 return (m_handle == NULL) && (rhs.m_handle == NULL);
01216 }
01217
01218 template <typename C, typename T, typename V>
01219 inline bool basic_search_sequence_const_iterator<C, T, V>::operator !=(class_type const &rhs) const
01220 {
01221 return ! operator ==(rhs);
01222 }
01223
01224 #endif
01225
01226
01227
01228 #if !defined(RECLS_NO_NAMESPACE)
01229 }
01230 }
01231
01232
01233 # if defined(STLSOFT_COMPILER_IS_MSVC) && \
01234 _MSC_VER < 1310
01235
01236 template< ss_typename_param_k C
01237 , ss_typename_param_k T
01238 >
01239 inline std::basic_ostream<C> &operator <<(std::basic_ostream<C> &s, recls::stl::basic_search_sequence_value_type<C, T> const &v)
01240 {
01241 #ifdef RECLS_PURE_API
01242 s << v.c_str();
01243 #else
01244 s << stlsoft_ns_qual(c_str_ptr)(v.get_path());
01245 #endif
01246
01247 return s;
01248 }
01249
01250 # endif
01251
01252
01253 namespace stlsoft
01254 {
01255 using recls::stl::is_empty;
01256 #ifndef RECLS_PURE_API
01257 using recls::stl::c_str_data;
01258 using recls::stl::c_str_len;
01259 using recls::stl::c_str_ptr;
01260 #ifdef RECLS_CHAR_TYPE_IS_CHAR
01261 using recls::stl::c_str_data_a;
01262 using recls::stl::c_str_len_a;
01263 using recls::stl::c_str_ptr_a;
01264 #endif
01265 # ifdef RECLS_CHAR_TYPE_IS_WCHAR
01266 using recls::stl::c_str_data_w;
01267 using recls::stl::c_str_len_w;
01268 using recls::stl::c_str_ptr_w;
01269 # endif
01270 #endif
01271
01272 }
01273 #endif
01274
01275
01276
01277 #endif
01278
01279