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

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