00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00058
00059
00060
00061
00062 #ifndef RECLS_INCL_RECLS_STL_HPP_RECLS
00063 # include <recls/stl/recls.hpp>
00064 #endif
00065 #ifndef RECLS_INCL_RECLS_STL_HPP_TRAITS
00066 # include <recls/stl/traits.hpp>
00067 #endif
00068 #include <platformstl/file_path_buffer.hpp>
00069 #include <stlsoft/simple_string.hpp>
00070
00071
00072
00073
00074
00075 #if !defined(RECLS_NO_NAMESPACE)
00076 namespace recls
00077 {
00078
00079 namespace stl
00080 {
00081 #endif
00082
00083 typedef platformstl::basic_file_path_buffer<recls_char_t> file_path_buffer;
00084
00085
00086
00087
00088
00089 #ifndef RECLS_DOCUMENTATION_SKIP_SECTION
00090
00091 template< typename C
00092 , typename T
00093 >
00094 class basic_search_sequence_value_type;
00095
00096 template< typename C
00097 , typename T
00098 , typename V
00099 >
00100 class basic_search_sequence_const_iterator;
00101
00102 #endif
00103
00104
00105
00106
00107
00108 #ifndef RECLS_DOCUMENTATION_SKIP_SECTION
00109 struct rss_shared_handle
00110 {
00111 hrecls_t hSrch;
00112 recls_sint32_t cRefs;
00113
00114 public:
00115 explicit rss_shared_handle(hrecls_t h)
00116 : hSrch(h)
00117 , cRefs(1)
00118 {}
00119 void Release()
00120 {
00121 if(--cRefs == 0)
00122 {
00123 delete this;
00124 }
00125 }
00126 #if defined(STLSOFT_COMPILER_IS_GCC)
00127 protected:
00128 #else
00129 private:
00130 #endif
00131 ~rss_shared_handle()
00132 {
00133 RECLS_MESSAGE_ASSERT("Shared search handle being destroyed with outstanding references!", 0 == cRefs);
00134
00135 if(NULL != hSrch)
00136 {
00137 Recls_SearchClose(hSrch);
00138 }
00139 }
00140 };
00141 #endif
00142
00143
00144
00145
00146
00147
00154
00155 #ifdef __STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_CLASS_ARGUMENT_SUPPORT
00156 , typename T = reclstl_traits<C>
00157 #else
00158 , typename T
00159 #endif
00160 >
00161 class basic_search_sequence
00162 {
00165 public:
00167 typedef C char_type;
00169 typedef T traits_type;
00171 typedef basic_search_sequence<C, T> class_type;
00173 typedef basic_search_sequence_value_type<C, T> value_type;
00175 typedef basic_search_sequence_const_iterator<C, T, value_type> const_iterator;
00177 typedef value_type &reference;
00179 typedef value_type const &const_reference;
00181 typedef ss_typename_type_k traits_type::entry_type entry_type;
00183 typedef size_t size_type;
00185 typedef ptrdiff_t difference_type;
00187 typedef stlsoft::basic_simple_string<C> string_type;
00189
00192 public:
00194 basic_search_sequence(char_type const *pattern, recls_uint32_t flags);
00195 #if defined(__STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT)
00196
00197 template <typename S>
00198 basic_search_sequence(S const &pattern, recls_uint32_t flags)
00199 : m_directory(copy_or_null_(m_directory_, stlsoft_ns_qual(c_str_ptr)("")))
00200 , m_pattern(copy_or_null_(m_pattern_, stlsoft_ns_qual(c_str_ptr)(pattern)))
00201 , m_flags(flags)
00202 {}
00203 #endif
00204
00205 basic_search_sequence(char_type const *directory, char_type const *pattern, recls_uint32_t flags);
00206 #if defined(__STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT)
00207
00208 template <typename S1, typename S2>
00209 basic_search_sequence(S1 const &directory, S2 const &pattern, recls_uint32_t flags)
00210 : m_directory(copy_or_null_(m_directory_, stlsoft_ns_qual(c_str_ptr)(directory)))
00211 , m_pattern(copy_or_null_(m_pattern_, stlsoft_ns_qual(c_str_ptr)(pattern)))
00212 , m_flags(flags)
00213 {}
00214 #endif
00215 #if defined(RECLS_API_FTP)
00216
00217 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);
00218 #endif
00219
00220 ~basic_search_sequence()
00221 {
00222 #if !defined(RECLS_COMPILER_IS_COMO) && \
00223 !defined(RECLS_COMPILER_IS_GCC) && \
00224 !defined(RECLS_COMPILER_IS_INTEL)
00225 STLSOFT_STATIC_ASSERT(STLSOFT_RAW_OFFSETOF(class_type, m_directory_) < STLSOFT_RAW_OFFSETOF(class_type, m_directory));
00226 STLSOFT_STATIC_ASSERT(STLSOFT_RAW_OFFSETOF(class_type, m_pattern_) < STLSOFT_RAW_OFFSETOF(class_type, m_pattern));
00227 #endif
00228 }
00230
00233 public:
00237 const_iterator begin() const;
00241 const_iterator end() const;
00243
00246 public:
00248 size_type size() const;
00250 recls_bool_t empty() const;
00252 static size_type max_size();
00254
00257 private:
00258 friend class basic_search_sequence_value_type<C, T>;
00259 friend class basic_search_sequence_const_iterator<C, T, value_type>;
00260
00261
00262 static char_type const *copy_or_null_(file_path_buffer &dest, char_type const *src)
00263 {
00264 return (NULL == src) ? static_cast<char_type const*>(NULL) : traits_type::str_copy(&dest[0], src);
00265 }
00266
00267 #if defined(RECLS_API_FTP)
00268 const string_type m_host;
00269 const string_type m_username;
00270 const string_type m_password;
00271 #endif
00272
00273 file_path_buffer m_directory_;
00274 file_path_buffer m_pattern_;
00275 char_type const *const m_directory;
00276 char_type const *const m_pattern;
00277 recls_uint32_t m_flags;
00279
00280
00281 private:
00282 basic_search_sequence(class_type const &);
00283 basic_search_sequence const &operator =(class_type const &);
00284 };
00285
00286
00287
00288
00289
00291 typedef basic_search_sequence<recls_char_a_t, reclstl_traits<recls_char_a_t> > search_sequence_a;
00293 typedef basic_search_sequence<recls_char_w_t, reclstl_traits<recls_char_w_t> > search_sequence_w;
00294
00295 #if defined(WIN32)
00296 typedef basic_search_sequence<TCHAR, reclstl_traits<TCHAR> > search_sequence;
00297 #else
00298 typedef search_sequence_a search_sequence;
00299 #endif
00300
00301
00302
00303
00307
00308
00309
00310
00311
00314
00316
00318
00320
00322
00324
00326
00329
00331
00332
00333
00334
00335
00336
00337
00339
00340
00342
00344
00347
00349
00351
00353
00354
00355
00356
00358 string_t get_directory() const;
00360 string_t get_directory_path() const;
00362 string_t get_UNC_drive() const;
00363 #ifndef RECLS_PURE_API
00364
00365 directory_parts_type get_directory_parts() const;
00366 #endif
00367
00368 string_t get_file() const;
00370 string_t get_short_file() const;
00372 string_t get_filename() const;
00374 string_t get_fileext() const;
00375
00376 recls_time_t get_creation_time() const;
00377 recls_time_t get_modification_time() const;
00378 recls_time_t get_last_access_time() const;
00379 recls_time_t get_last_status_change_time() const;
00380
00381 recls_filesize_t get_size() const;
00382
00383 recls_bool_t is_readonly() const;
00384 recls_bool_t is_directory() const;
00385 recls_bool_t is_link() const;
00387 recls_bool_t is_UNC() const;
00388
00389 #ifndef RECLS_PURE_API
00390
00391 char_type const *c_str() const;
00392 #endif
00393
00395 entry_type const &get_entry() const;
00397
00399 public:
00400 #ifdef RECLS_STL_METHOD_PROPERTY_SUPPORT
00401 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, path);
00402 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, search_directory);
00403 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, search_relative_path);
00404 #ifdef RECLS_STL_PLATFORM_API_WIN32
00405 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, drive);
00406 #endif
00407 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, directory);
00408 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, directory_path);
00409 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, UNC_drive);
00410 #ifndef RECLS_STL_PURE_API
00411 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, directory_parts);
00412 #endif
00413 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, file);
00414 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, short_file);
00415 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, filename);
00416 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, fileext);
00417 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, creation_time);
00418 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, modification_time);
00419 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, last_access_time);
00420 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, last_status_change_time);
00421 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, size);
00422 RECLS_STL_OPT_METHOD_PROPERTY_DEFINE_OFFSET(class_type, entry);
00423 union
00424 {
00425 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(string_t, class_type, get_path, path);
00426 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(string_t, class_type, get_search_directory, search_directory);
00427 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(string_t, class_type, get_search_relative_path, search_relative_path);
00428 #ifdef RECLS_STL_PLATFORM_API_WIN32
00429 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(char_type, class_type, get_drive, drive);
00430 #endif
00431 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(string_t, class_type, get_directory, directory);
00432 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(string_t, class_type, get_directory_path, directory_path);
00433 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(string_t, class_type, get_UNC_drive, UNC_drive);
00434 #ifndef RECLS_STL_PURE_API
00435 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(directory_parts_type, class_type, get_directory_parts, directory_parts);
00436 #endif
00437 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(string_t, class_type, get_file, file);
00438 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(string_t, class_type, get_short_file, short_file);
00439 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(string_t, class_type, get_filename, filename);
00440 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(string_t, class_type, get_fileext, fileext);
00441 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(recls_time_t, class_type, get_creation_time, creation_time);
00442 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(recls_time_t, class_type, get_modification_time, modification_time);
00443 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(recls_time_t, class_type, get_last_access_time, last_access_time);
00444 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(recls_time_t, class_type, get_last_status_change_time, last_status_change_time);
00445 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(recls_filesize_t, class_type, get_size, size);
00446 RECLS_STL_OPT_METHOD_PROPERTY_GET_PROP(entry_type const&, class_type, get_entry, entry);
00447 };
00448 #endif
00449
00450
00452 private:
00453 static string_t get_string_(size_t (RECLS_CALLCONV_DEFAULT *pfn)(recls_info_t, recls_char_t *, size_t), entry_type info)
00454 {
00455 file_path_buffer buffer;
00456 size_t cch = pfn(info, &buffer[0], buffer.size());
00457
00458 return string_t(&buffer[0], cch);
00459 }
00460
00461
00462 private:
00463 friend class basic_search_sequence_const_iterator<C, T, class_type>;
00464
00465 entry_type m_info;
00466 };
00467
00468
00472
00473 , typename T
00474 , typename V
00475 >
00476 class basic_search_sequence_const_iterator
00477 : public stlsoft_ns_qual(iterator_base)<stlsoft_ns_qual_std(input_iterator_tag), V, ptrdiff_t, void, V>
00478 {
00479 public:
00481 typedef C char_type;
00483 typedef T traits_type;
00485 typedef V value_type;
00487 typedef basic_search_sequence_const_iterator<C, T, V> class_type;
00489 typedef ss_typename_type_k traits_type::entry_type entry_type;
00490 private:
00491 typedef basic_search_sequence<C, T> sequence_type;
00492
00493 private:
00494 explicit basic_search_sequence_const_iterator(hrecls_t hSrch)
00495 : m_handle(make_handle_(hSrch))
00496 {}
00497 public:
00499 basic_search_sequence_const_iterator();
00501 basic_search_sequence_const_iterator(class_type const &rhs);
00503 ~basic_search_sequence_const_iterator();
00504
00505
00506 basic_search_sequence_const_iterator &operator =(class_type const &rhs);
00507
00508 public:
00510 class_type &operator ++();
00512 void operator ++(int);
00514 const value_type operator *() const;
00516 recls_bool_t operator ==(class_type const &rhs) const;
00518 recls_bool_t operator !=(class_type const &rhs) const;
00519
00520
00521 private:
00522 rss_shared_handle *make_handle_(hrecls_t hSrch);
00523
00524
00525 private:
00526 friend class basic_search_sequence<C, T>;
00527
00528 rss_shared_handle *m_handle;
00529 };
00530
00532
00533
00544 template <typename C, typename T>
00545 inline recls_bool_t is_empty(basic_search_sequence<C, T> const &s)
00546 {
00547 return s.empty();
00548 }
00549
00550 #ifndef RECLS_PURE_API
00561 template <typename C, typename T>
00562 #ifndef RECLS_DOCUMENTATION_SKIP_SECTION
00563 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)
00564 #else
00565 inline C const *c_str_ptr(basic_search_sequence_value_type<C, T> const &v)
00566 #endif
00567 {
00568 return v.c_str();
00569 }
00570
00571 template <typename C, typename T>
00572 inline size_t c_str_len(basic_search_sequence_value_type<C, T> const &v)
00573 {
00574 return stlsoft_ns_qual(c_str_len)(v.c_str());
00575 }
00576 #endif
00577
00579
00580
00581 template< typename S
00582 , typename C
00583 , typename T
00584 >
00585 inline S &operator <<(S &s, basic_search_sequence_value_type<C, T> const &v)
00586 {
00587 #ifdef RECLS_PURE_API
00588 s << v.c_str();
00589 #else
00590 s << stlsoft_ns_qual(c_str_ptr)(v.get_path());
00591 #endif
00592
00593 return s;
00594 }
00595
00597
00598
00599 #ifndef RECLS_DOCUMENTATION_SKIP_SECTION
00600
00601
00602
00603
00604
00605 template <typename C, typename T>
00606 inline basic_search_sequence<C, T>::basic_search_sequence(char_type const *pattern, recls_uint32_t flags)
00607 : m_directory(copy_or_null_(m_directory_, ""))
00608 , m_pattern(copy_or_null_(m_pattern_, pattern))
00609 , m_flags(flags)
00610 {}
00611
00612 template <typename C, typename T>
00613 inline basic_search_sequence<C, T>::basic_search_sequence(char_type const *directory, char_type const *pattern, recls_uint32_t flags)
00614 : m_directory(copy_or_null_(m_directory_, directory))
00615 , m_pattern(copy_or_null_(m_pattern_, pattern))
00616 , m_flags(flags)
00617 {}
00618
00619 #if defined(RECLS_API_FTP)
00620 template <typename C, typename T>
00621 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)
00622 : m_host(host)
00623 , m_username(username)
00624 , m_password(password)
00625 , m_directory(copy_or_null_(m_directory_, directory))
00626 , m_pattern(copy_or_null_(m_pattern_, pattern))
00627 , m_flags(flags)
00628 {
00629 RECLS_MESSAGE_ASSERT("Must specify a hostname if using FTP", (NULL == username && NULL == password) || NULL != host);
00630 }
00631 #endif
00632
00633
00634 template <typename C, typename T>
00635 inline ss_typename_type_k basic_search_sequence<C, T>::const_iterator basic_search_sequence<C, T>::begin() const
00636 {
00637 hrecls_t hSrch;
00638 recls_rc_t rc;
00639
00640 #if defined(RECLS_API_FTP)
00641 if(m_host.empty())
00642 {
00643 #endif
00644 rc = traits_type::Search(m_directory, m_pattern, m_flags, &hSrch);
00645 #if defined(RECLS_API_FTP)
00646 }
00647 else
00648 {
00649 rc = traits_type::SearchFtp(m_host.c_str(), m_username.c_str(), m_password.c_str(), m_directory, m_pattern, m_flags, &hSrch);
00650 }
00651 #endif
00652
00653 #ifdef __STLSOFT_CF_EXCEPTION_SUPPORT
00654 if( RECLS_FAILED(rc) &&
00655 RECLS_RC_NO_MORE_DATA != rc)
00656 {
00657 throw recls_exception(rc);
00658 }
00659 #endif
00660
00661 return const_iterator(hSrch);
00662 }
00663
00664 template <typename C, typename T>
00665 inline ss_typename_type_k basic_search_sequence<C, T>::const_iterator basic_search_sequence<C, T>::end() const
00666 {
00667 return const_iterator();
00668 }
00669
00670
00671 template <typename C, typename T>
00672 inline ss_typename_type_k basic_search_sequence<C, T>::size_type basic_search_sequence<C, T>::size() const
00673 {
00674 const_iterator b = begin();
00675 const_iterator e = end();
00676 size_type c = 0;
00677
00678 for(; b != e; ++b)
00679 {
00680 ++c;
00681 }
00682
00683 return c;
00684 }
00685
00686 template <typename C, typename T>
00687 inline recls_bool_t basic_search_sequence<C, T>::empty() const
00688 {
00689 return begin() == end();
00690 }
00691
00692 template <typename C, typename T>
00693 inline ss_typename_type_k basic_search_sequence<C, T>::size_type basic_search_sequence<C, T>::max_size()
00694 {
00695 return static_cast<size_type>(-1);
00696 }
00697
00698
00699
00700
00701 template <typename C, typename T>
00702 inline basic_search_sequence_value_type<C, T>::basic_search_sequence_value_type()
00703 : m_info(NULL)
00704 {}
00705
00706 template <typename C, typename T>
00707 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)
00708 : m_info(traits_type::CopyDetails(rhs.m_info))
00709 {}
00710
00711 template <typename C, typename T>
00712 inline basic_search_sequence_value_type<C, T>::~basic_search_sequence_value_type()
00713 {
00714 if(NULL != m_info)
00715 {
00716 traits_type::CloseDetails(m_info);
00717 }
00718 }
00719
00720 template <typename C, typename T>
00721 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)
00722 {
00723 if(NULL != m_info)
00724 {
00725 traits_type::CloseDetails(m_info);
00726 }
00727
00728 m_info = traits_type::CopyDetails(rhs.m_info);
00729
00730 return *this;
00731 }
00732
00733 template <typename C, typename T>
00734 inline string_t basic_search_sequence_value_type<C, T>::get_path() const
00735 {
00736 RECLS_ASSERT(NULL != m_info);
00737
00738 #ifdef RECLS_PURE_API
00739 return get_string_(Recls_GetPathProperty, m_info);
00740 #else
00741 return string_t(m_info->path.begin, m_info->path.end);
00742 #endif
00743 }
00744
00745 template <typename C, typename T>
00746 inline string_t basic_search_sequence_value_type<C, T>::get_search_directory() const
00747 {
00748 RECLS_ASSERT(NULL != m_info);
00749
00750 #ifdef RECLS_PURE_API
00751 return get_string_(Recls_GetSearchDirectoryProperty, m_info);
00752 #else
00753 return string_t(m_info->searchDirectory.begin, m_info->searchDirectory.end);
00754 #endif
00755 }
00756
00757 template <typename C, typename T>
00758 inline string_t basic_search_sequence_value_type<C, T>::get_search_relative_path() const
00759 {
00760 RECLS_ASSERT(NULL != m_info);
00761
00762 #ifdef RECLS_PURE_API
00763 return get_string_(Recls_GetSearchRelativePatahProperty, m_info);
00764 #else
00765 return string_t(m_info->searchRelativePath.begin, m_info->searchRelativePath.end);
00766 #endif
00767 }
00768
00769 #ifdef RECLS_PLATFORM_API_WIN32
00770 template <typename C, typename T>
00771 inline ss_typename_type_k basic_search_sequence_value_type<C, T>::char_type basic_search_sequence_value_type<C, T>::get_drive() const
00772 {
00773 char_type chDrive;
00774
00775 return (Recls_GetDriveProperty(m_info, &chDrive), chDrive);
00776 }
00777 #endif
00778
00779 template <typename C, typename T>
00780 inline string_t basic_search_sequence_value_type<C, T>::get_directory() const
00781 {
00782 RECLS_ASSERT(NULL != m_info);
00783
00784 #ifdef RECLS_PURE_API
00785 return get_string_(Recls_GetDirectoryProperty, m_info);
00786 #else
00787 return string_t(m_info->directory.begin, m_info->directory.end);
00788 #endif
00789 }
00790
00791 template <typename C, typename T>
00792 inline string_t basic_search_sequence_value_type<C, T>::get_directory_path() const
00793 {
00794 RECLS_ASSERT(NULL != m_info);
00795
00796 #ifdef RECLS_PURE_API
00797 return get_string_(Recls_GetDirectoryPathProperty, m_info);
00798 #else
00799 return string_t(m_info->path.begin, m_info->directory.end);
00800 #endif
00801 }
00802
00803 template <typename C, typename T>
00804 inline string_t basic_search_sequence_value_type<C, T>::get_UNC_drive() const
00805 {
00806 RECLS_ASSERT(NULL != m_info);
00807
00808 #if 0
00809 if(!is_UNC())
00810 {
00811 return string_t();
00812 }
00813 else
00814 {
00815 #ifdef RECLS_PURE_API
00816 string_t directoryPath = get_directory_path();
00817 size_t directoryLen = Recls_GetDirectoryProperty(m_info, NULL, 0);
00818
00819 return string_t(directoryPath, 0, directoryPath.length() - directoryLen);
00820 #else
00821 return string_t(m_info->path.begin, m_info->directory.begin);
00822 #endif
00823 }
00824 #else
00825 # ifdef RECLS_PURE_API
00826 return get_string_(Recls_GetUNCDriveProperty, m_info);
00827 # else
00828 return string_t(m_info->path.begin, m_info->directory.begin);
00829 # endif
00830 #endif
00831 }
00832
00833 #ifndef RECLS_PURE_API
00834 template <typename C, typename T>
00835 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
00836 {
00837 RECLS_ASSERT(NULL != m_info);
00838
00839 return directory_parts_type(m_info->directoryParts.begin, m_info->directoryParts.end);
00840 }
00841 #endif
00842
00843 template <typename C, typename T>
00844 inline string_t basic_search_sequence_value_type<C, T>::get_file() const
00845 {
00846 RECLS_ASSERT(NULL != m_info);
00847
00848 #ifdef RECLS_PURE_API
00849 return get_string_(Recls_GetFileProperty, m_info);
00850 #else
00851 return string_t(m_info->fileName.begin, m_info->fileExt.end);
00852 #endif
00853 }
00854
00855 template <typename C, typename T>
00856 inline string_t basic_search_sequence_value_type<C, T>::get_short_file() const
00857 {
00858 RECLS_ASSERT(NULL != m_info);
00859
00860 return get_string_(Recls_GetShortFileProperty, m_info);
00861 }
00862
00863 template <typename C, typename T>
00864 inline string_t basic_search_sequence_value_type<C, T>::get_filename() const
00865 {
00866 RECLS_ASSERT(NULL != m_info);
00867
00868 #ifdef RECLS_PURE_API
00869 return get_string_(Recls_GetFileNameProperty, m_info);
00870 #else
00871 return string_t(m_info->fileName.begin, m_info->fileName.end);
00872 #endif
00873 }
00874
00875 template <typename C, typename T>
00876 inline string_t basic_search_sequence_value_type<C, T>::get_fileext() const
00877 {
00878 RECLS_ASSERT(NULL != m_info);
00879
00880 #ifdef RECLS_PURE_API
00881 return get_string_(Recls_GetFileExtProperty, m_info);
00882 #else
00883 return string_t(m_info->fileExt.begin, m_info->fileExt.end);
00884 #endif
00885 }
00886
00887 template <typename C, typename T>
00888 inline recls_time_t basic_search_sequence_value_type<C, T>::get_creation_time() const
00889 {
00890 RECLS_ASSERT(NULL != m_info);
00891
00892 return Recls_GetCreationTime(m_info);
00893 }
00894
00895 template <typename C, typename T>
00896 inline recls_time_t basic_search_sequence_value_type<C, T>::get_modification_time() const
00897 {
00898 RECLS_ASSERT(NULL != m_info);
00899
00900 return Recls_GetModificationTime(m_info);
00901 }
00902
00903 template <typename C, typename T>
00904 inline recls_time_t basic_search_sequence_value_type<C, T>::get_last_access_time() const
00905 {
00906 RECLS_ASSERT(NULL != m_info);
00907
00908 return Recls_GetLastAccessTime(m_info);
00909 }
00910
00911 template <typename C, typename T>
00912 inline recls_time_t basic_search_sequence_value_type<C, T>::get_last_status_change_time() const
00913 {
00914 RECLS_ASSERT(NULL != m_info);
00915
00916 return Recls_GetLastStatusChangeTime(m_info);
00917 }
00918
00919 template <typename C, typename T>
00920 inline recls_filesize_t basic_search_sequence_value_type<C, T>::get_size() const
00921 {
00922 RECLS_ASSERT(NULL != m_info);
00923
00924 #ifdef RECLS_PURE_API
00925 recls_filesize_t size;
00926
00927 return (Recls_GetSizeProperty(m_info, &size), size);
00928 #else
00929 return m_info->size;
00930 #endif
00931 }
00932
00933 template <typename C, typename T>
00934 inline recls_bool_t basic_search_sequence_value_type<C, T>::is_readonly() const
00935 {
00936 RECLS_ASSERT(NULL != m_info);
00937
00938 return Recls_IsFileReadOnly(m_info);
00939 }
00940
00941 template <typename C, typename T>
00942 inline recls_bool_t basic_search_sequence_value_type<C, T>::is_directory() const
00943 {
00944 RECLS_ASSERT(NULL != m_info);
00945
00946 return Recls_IsFileDirectory(m_info);
00947 }
00948
00949 template <typename C, typename T>
00950 inline recls_bool_t basic_search_sequence_value_type<C, T>::is_link() const
00951 {
00952 RECLS_ASSERT(NULL != m_info);
00953
00954 return Recls_IsFileLink(m_info);
00955 }
00956
00957 template <typename C, typename T>
00958 inline recls_bool_t basic_search_sequence_value_type<C, T>::is_UNC() const
00959 {
00960 RECLS_ASSERT(NULL != m_info);
00961
00962 return Recls_IsFileUNC(m_info);
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>::char_type const * basic_search_sequence_value_type<C, T>::c_str() const
00968 {
00969 RECLS_ASSERT(NULL != m_info);
00970
00971 return m_info->path.begin;
00972 }
00973 #endif
00974
00975 template <typename C, typename T>
00976 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
00977 {
00978 return m_info;
00979 }
00980
00981
00982
00983 template <typename C, typename T, typename V>
00984 inline rss_shared_handle *basic_search_sequence_const_iterator<C, T, V>::make_handle_(hrecls_t hSrch)
00985 {
00986 return (NULL != hSrch) ? new rss_shared_handle(hSrch) : static_cast<rss_shared_handle*>(NULL);
00987 }
00988
00989 template <typename C, typename T, typename V>
00990 inline basic_search_sequence_const_iterator<C, T, V>::basic_search_sequence_const_iterator()
00991 : m_handle(NULL)
00992 {}
00993
00994 template <typename C, typename T, typename V>
00995 inline basic_search_sequence_const_iterator<C, T, V>::basic_search_sequence_const_iterator(class_type const &rhs)
00996 : m_handle(rhs.m_handle)
00997 {
00998 if(NULL != m_handle)
00999 {
01000 ++m_handle->cRefs;
01001 }
01002 }
01003
01004 template <typename C, typename T, typename V>
01005 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)
01006 {
01007 if(NULL != m_handle)
01008 {
01009 m_handle->Release();
01010 }
01011
01012 m_handle = rhs.m_handle;
01013
01014 if(NULL != m_handle)
01015 {
01016 ++m_handle->cRefs;
01017 }
01018
01019 return *this;
01020 }
01021
01022 template <typename C, typename T, typename V>
01023 inline basic_search_sequence_const_iterator<C, T, V>::~basic_search_sequence_const_iterator()
01024 {
01025 if(NULL != m_handle)
01026 {
01027 m_handle->Release();
01028 }
01029 }
01030
01031 template <typename C, typename T, typename V>
01032 inline ss_typename_type_k basic_search_sequence_const_iterator<C, T, V>::class_type &basic_search_sequence_const_iterator<C, T, V>::operator ++()
01033 {
01034 #if !defined(STLSOFT_COMPILER_IS_GCC) // GCC on Mac has a cow here
01035 RECLS_MESSAGE_ASSERT("Attempting to increment invalid iterator", NULL != m_handle);
01036 #endif
01037
01038 if(RECLS_FAILED(Recls_GetNext(m_handle->hSrch)))
01039 {
01040 m_handle->Release();
01041
01042 m_handle = NULL;
01043 }
01044
01045 return *this;
01046 }
01047
01048 template <typename C, typename T, typename V>
01049 inline void basic_search_sequence_const_iterator<C, T, V>::operator ++(int)
01050 {
01051 operator ++();
01052 }
01053
01054 template <typename C, typename T, typename V>
01055 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
01056 {
01057 entry_type info;
01058
01059 #if !defined(STLSOFT_COMPILER_IS_GCC) // GCC on Mac has a cow here
01060 RECLS_MESSAGE_ASSERT("Attempting to dereference invalid iterator", NULL != m_handle);
01061 #endif
01062
01063 if( m_handle->hSrch != NULL &&
01064 RECLS_SUCCEEDED(traits_type::GetDetails(m_handle->hSrch, &info)))
01065 {
01066 return value_type(info);
01067 }
01068 else
01069 {
01070 RECLS_MESSAGE_ASSERT("Dereferencing end()-valued iterator", 0);
01071
01072 return value_type();
01073 }
01074 }
01075
01076 template <typename C, typename T, typename V>
01077 inline recls_bool_t basic_search_sequence_const_iterator<C, T, V>::operator ==(class_type const &rhs) const
01078 {
01079 return (m_handle == NULL) && (rhs.m_handle == NULL);
01080 }
01081
01082 template <typename C, typename T, typename V>
01083 inline recls_bool_t basic_search_sequence_const_iterator<C, T, V>::operator !=(class_type const &rhs) const
01084 {
01085 return ! operator ==(rhs);
01086 }
01087
01088 #endif
01089
01090
01091
01092
01093
01094 }
01095
01096
01097 namespace stlsoft
01098 {
01099 using recls::stl::is_empty;
01100 #ifndef RECLS_PURE_API
01101 using recls::stl::c_str_ptr;
01102 using recls::stl::c_str_len;
01103 #endif
01104
01105 }
01106 #endif
01107
01108
01109
01110
01111
01112