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

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

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