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

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