C/C++ User's Journal STLSoft - ... Robust, Lightweight, Cross-platform, Template Software ... ATLSTL - where the Standard Template Library meets the Active Template Library COMSTL - where the Standard Template Library meets the Component Object Model
Synesis Software InetSTL - where the Standard Template Library meets the Internet UNIXSTL - Template Software for the UNIX Operating System WinSTL - where the Standard Template Library meets the Win32 API

Main Page   Modules   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

/include/recls/stl/search_sequence.hpp

Go to the documentation of this file.
00001 /* 
00002  * File:        recls/stl/search_sequence.hpp
00003  *
00004  * Purpose:     Contains the basic_search_sequence template class, and ANSI
00005  *              and Unicode specialisations thereof.
00006  *
00007  * Created:     10th September 2003
00008  * Updated:     27th December 2005
00009  *
00010  * Home:        http://recls.org/
00011  *
00012  * Copyright (c) 2003-2005, Matthew Wilson and Synesis Software
00013  * All rights reserved.
00014  *
00015  * Redistribution and use in source and binary forms, with or without 
00016  * modification, are permitted provided that the following conditions are met:
00017  *
00018  * - Redistributions of source code must retain the above copyright notice, this
00019  *   list of conditions and the following disclaimer. 
00020  * - Redistributions in binary form must reproduce the above copyright notice,
00021  *   this list of conditions and the following disclaimer in the documentation
00022  *   and/or other materials provided with the distribution.
00023  * - Neither the name(s) of Matthew Wilson and Synesis Software nor the names of
00024  *   any contributors may be used to endorse or promote products derived from
00025  *   this software without specific prior written permission.
00026  *
00027  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
00028  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00029  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
00030  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
00031  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
00032  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
00033  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
00034  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
00035  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
00036  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
00037  * POSSIBILITY OF SUCH DAMAGE.
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    3
00048 # define RECLS_VER_RECLSTL_STL_HPP_SEARCH_SEQUENCE_REVISION 3
00049 # define RECLS_VER_RECLSTL_STL_HPP_SEARCH_SEQUENCE_EDIT     50
00050 #endif /* !RECLS_DOCUMENTATION_SKIP_SECTION */
00051 
00058 /* 
00059  * Includes
00060  */
00061 
00062 #ifndef RECLS_INCL_RECLS_STL_HPP_RECLS
00063 # include <recls/stl/recls.hpp>
00064 #endif /* !RECLS_INCL_RECLS_STL_HPP_RECLS */
00065 #ifndef RECLS_INCL_RECLS_STL_HPP_TRAITS
00066 # include <recls/stl/traits.hpp>
00067 #endif /* !RECLS_INCL_RECLS_STL_HPP_TRAITS */
00068 #include <platformstl/file_path_buffer.hpp>
00069 #include <stlsoft/simple_string.hpp>
00070 
00071 /* 
00072  * Namespace
00073  */
00074 
00075 #if !defined(RECLS_NO_NAMESPACE)
00076 namespace recls
00077 {
00078 
00079 namespace stl
00080 {
00081 #endif /* !RECLS_NO_NAMESPACE */
00082 
00083 typedef platformstl::basic_file_path_buffer<recls_char_t>   file_path_buffer;
00084 
00085 /* 
00086  * Forward declarations
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 /* !RECLS_DOCUMENTATION_SKIP_SECTION */
00103 
00104 /* 
00105  * Utility classes
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 /* ? compiler */
00129 private:
00130 #endif /* compiler */
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 /* !RECLS_DOCUMENTATION_SKIP_SECTION */
00142 
00143 /* 
00144  * Classes
00145  */
00146 
00147 // class basic_search_sequence
00154 template<   typename C
00155 #ifdef __STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_CLASS_ARGUMENT_SUPPORT
00156         ,   typename T = reclstl_traits<C>
00157 #else
00158         ,   typename T /* = reclstl_traits<C> */
00159 #endif /* __STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_CLASS_ARGUMENT_SUPPORT */
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 /* __STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT */
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 /* __STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT */
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 /* RECLS_API_FTP */
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 /* compiler */
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     // This one is implemented in-class as it allows sequence to be used by VC++ 5
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 /* RECLS_API_FTP */
00272     // TODO: Lose the file_path_buffer, and use auto_buffer directly
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 // Not to be implemented
00281 private:
00282     basic_search_sequence(class_type const &);
00283     basic_search_sequence const &operator =(class_type const &);
00284 };
00285 
00286 /* 
00287  * Typedefs for commonly encountered types
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 /* WIN32 */
00300 
00301 /* 
00302 
00303 // class basic_search_sequence_value_type
00307 template<   typename C
00308         ,   typename T
00309         >
00310 class basic_search_sequence_value_type
00311 {
00314 public:
00316     typedef C                                                       char_type;
00318     typedef T                                                       traits_type;
00320     typedef basic_search_sequence_value_type<C, T>                  class_type;
00322     typedef ss_typename_type_k traits_type::entry_type              entry_type;
00324     typedef ss_typename_type_k traits_type::directory_parts_type    directory_parts_type;
00326 
00329 public:
00331     basic_search_sequence_value_type();
00332     basic_search_sequence_value_type(class_type const &rhs);
00333 private:
00334     basic_search_sequence_value_type(entry_type info)
00335         : m_info(info)
00336     {}
00337 public:
00339     ~basic_search_sequence_value_type();
00340 
00342     class_type &operator =(class_type const &rhs);
00344 
00347 public:
00349     string_t                get_path() const;
00351     string_t                get_search_relative_path() const;
00353     string_t                get_search_directory() const;
00354 #ifdef RECLS_PLATFORM_API_WIN32
00355     char_type               get_drive() const;
00356 #endif /* RECLS_PLATFORM_API_WIN32 */
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 /* !RECLS_PURE_API */
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 /* !RECLS_PURE_API */
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 /* RECLS_STL_PLATFORM_API_WIN32 */
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 /* !RECLS_STL_PURE_API */
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 /* RECLS_STL_PLATFORM_API_WIN32 */
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 /* !RECLS_STL_PURE_API */
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 /* RECLS_STL_METHOD_PROPERTY_SUPPORT */
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 // Members
00462 private:
00463     friend class basic_search_sequence_const_iterator<C, T, class_type>;
00464 
00465     entry_type  m_info;
00466 };
00467 
00468 // class basic_search_sequence_const_iterator
00472 template<   typename C
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     // Copy assignment operator
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 // Implementation
00521 private:
00522     rss_shared_handle   *make_handle_(hrecls_t hSrch);
00523 
00524 // Members
00525 private:
00526     friend class basic_search_sequence<C, T>;
00527 
00528     rss_shared_handle   *m_handle;
00529 };
00530 
00532 // Shims
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 /* !RECLS_DOCUMENTATION_SKIP_SECTION */
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 /* !RECLS_PURE_API */
00577 
00579 // IOStream compatibility
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 /* ? RECLS_PURE_API */
00590     s << stlsoft_ns_qual(c_str_ptr)(v.get_path());
00591 #endif /* RECLS_PURE_API */
00592 
00593     return s;
00594 }
00595 
00597 // Implementation
00598 
00599 #ifndef RECLS_DOCUMENTATION_SKIP_SECTION
00600 
00601 // basic_search_sequence
00602 
00603 
00604 // Construction
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 /* RECLS_API_FTP */
00632 
00633 // Iteration
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 /* RECLS_API_FTP */
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 /* RECLS_API_FTP */
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 /* __STLSOFT_CF_EXCEPTION_SUPPORT */
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 // State
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 /* static */ 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 // basic_search_sequence_value_type
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 /* ? RECLS_PURE_API */
00741     return string_t(m_info->path.begin, m_info->path.end);
00742 #endif /* RECLS_PURE_API */
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 /* ? RECLS_PURE_API */
00753     return string_t(m_info->searchDirectory.begin, m_info->searchDirectory.end);
00754 #endif /* RECLS_PURE_API */
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 /* ? RECLS_PURE_API */
00765     return string_t(m_info->searchRelativePath.begin, m_info->searchRelativePath.end);
00766 #endif /* RECLS_PURE_API */
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 /* RECLS_PLATFORM_API_WIN32 */
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 /* ? RECLS_PURE_API */
00787     return string_t(m_info->directory.begin, m_info->directory.end);
00788 #endif /* RECLS_PURE_API */
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 /* ? RECLS_PURE_API */
00799     return string_t(m_info->path.begin, m_info->directory.end);
00800 #endif /* RECLS_PURE_API */
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 /* ? RECLS_PURE_API */
00821         return string_t(m_info->path.begin, m_info->directory.begin);
00822 #endif /* RECLS_PURE_API */
00823     }
00824 #else /* ? 0 */
00825 # ifdef RECLS_PURE_API
00826     return get_string_(Recls_GetUNCDriveProperty, m_info);
00827 # else /* ? RECLS_PURE_API */
00828     return string_t(m_info->path.begin, m_info->directory.begin);
00829 # endif /* RECLS_PURE_API */
00830 #endif /* 0 */
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 /* !RECLS_PURE_API */
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 /* ? RECLS_PURE_API */
00851     return string_t(m_info->fileName.begin, m_info->fileExt.end);
00852 #endif /* RECLS_PURE_API */
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 /* ? RECLS_PURE_API */
00871     return string_t(m_info->fileName.begin, m_info->fileName.end);
00872 #endif /* RECLS_PURE_API */
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 /* ? RECLS_PURE_API */
00883     return string_t(m_info->fileExt.begin, m_info->fileExt.end);
00884 #endif /* RECLS_PURE_API */
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 /* ? RECLS_PURE_API */
00929     return m_info->size;
00930 #endif /* RECLS_PURE_API */
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 /* !RECLS_PURE_API */
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 // basic_search_sequence_const_iterator
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 /* compiler */
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 /* compiler */
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 /* !RECLS_DOCUMENTATION_SKIP_SECTION */
01089 
01090 /* 
01091 
01092 #if !defined(RECLS_NO_NAMESPACE)
01093 } /* namespace stl */
01094 } /* namespace recls */
01095 
01096 // Now we introduce the two shims into the STLSoft namespace - stlsoft.
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 /* !RECLS_PURE_API */
01104 
01105 } // namespace stlsoft
01106 #endif /* !RECLS_NO_NAMESPACE */
01107 
01108 /* 
01109 
01110 #endif /* RECLS_INCL_RECLSTL_STL_HPP_SEARCH_SEQUENCE */
01111 
01112 /* 

recls Library documentation © Synesis Software Pty Ltd, 2001-2005