00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00054 #ifndef WINSTL_INCL_WINSTL_FILESYSTEM_HPP_FINDVOLUME_SEQUENCE
00055 #define WINSTL_INCL_WINSTL_FILESYSTEM_HPP_FINDVOLUME_SEQUENCE
00056
00057 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00058 # define WINSTL_VER_WINSTL_FILESYSTEM_HPP_FINDVOLUME_SEQUENCE_MAJOR 4
00059 # define WINSTL_VER_WINSTL_FILESYSTEM_HPP_FINDVOLUME_SEQUENCE_MINOR 3
00060 # define WINSTL_VER_WINSTL_FILESYSTEM_HPP_FINDVOLUME_SEQUENCE_REVISION 6
00061 # define WINSTL_VER_WINSTL_FILESYSTEM_HPP_FINDVOLUME_SEQUENCE_EDIT 115
00062 #endif
00063
00064
00065
00066
00067
00068 #ifndef WINSTL_INCL_WINSTL_H_WINSTL
00069 # include <winstl/winstl.h>
00070 #endif
00071 #ifndef WINSTL_INCL_WINSTL_FILESYSTEM_HPP_FILESYSTEM_TRAITS
00072 # include <winstl/filesystem/filesystem_traits.hpp>
00073 #endif
00074 #ifndef STLSOFT_INCL_STLSOFT_UTIL_STD_HPP_ITERATOR_HELPER
00075 # include <stlsoft/util/std/iterator_helper.hpp>
00076 #endif
00077 #ifndef STLSOFT_INCL_STLSOFT_COLLECTIONS_UTIL_HPP_COLLECTIONS
00078 # include <stlsoft/collections/util/collections.hpp>
00079 #endif
00080
00081
00082
00083
00084
00085 #ifndef _WINSTL_NO_NAMESPACE
00086 # if defined(_STLSOFT_NO_NAMESPACE) || \
00087 defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
00088
00089 namespace winstl
00090 {
00091 # else
00092
00093
00094 namespace stlsoft
00095 {
00096
00097 namespace winstl_project
00098 {
00099
00100 # endif
00101 #endif
00102
00103
00104
00105
00106
00107
00108
00109
00110 enum
00111 {
00112 MAX_VOL_NAME = WINSTL_CONST_MAX_PATH
00113 };
00114
00115
00116
00117
00118
00119 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00120
00121 template <ss_typename_param_k C, ss_typename_param_k T>
00122 class basic_findvolume_sequence_value_type;
00123
00124 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V>
00125 class basic_findvolume_sequence_const_iterator;
00126
00127 #endif
00128
00129
00130
00131
00132
00133
00143 template< ss_typename_param_k C
00144 #ifdef STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_CLASS_ARGUMENT_SUPPORT
00145 , ss_typename_param_k T = filesystem_traits<C>
00146 #else
00147 , ss_typename_param_k T
00148 #endif
00149 >
00150 class basic_findvolume_sequence
00151 : public stlsoft_ns_qual(stl_collection_tag)
00152 {
00153 public:
00155 typedef C char_type;
00157 typedef T traits_type;
00159 typedef basic_findvolume_sequence<C, T> class_type;
00161 typedef basic_findvolume_sequence_value_type<C, T> value_type;
00163 typedef basic_findvolume_sequence_const_iterator<C, T, value_type> const_iterator;
00165 typedef value_type& reference;
00167 typedef value_type const& const_reference;
00168
00169
00170 public:
00174 const_iterator begin() const;
00178 const_iterator end() const;
00179
00180
00181 public:
00183 ws_bool_t empty() const;
00184 };
00185
00186
00187
00188
00189
00194 typedef basic_findvolume_sequence<ws_char_a_t, filesystem_traits<ws_char_a_t> > findvolume_sequence_a;
00199 typedef basic_findvolume_sequence<ws_char_w_t, filesystem_traits<ws_char_w_t> > findvolume_sequence_w;
00204 typedef basic_findvolume_sequence<TCHAR, filesystem_traits<TCHAR> > findvolume_sequence;
00205
00206
00207
00208
00213 template< ss_typename_param_k C
00214 , ss_typename_param_k T
00215 >
00216 class basic_findvolume_sequence_value_type
00217 {
00218 public:
00220 typedef C char_type;
00222 typedef T traits_type;
00224 typedef basic_findvolume_sequence_value_type<C, T> class_type;
00225
00226 public:
00228 basic_findvolume_sequence_value_type();
00230 basic_findvolume_sequence_value_type(class_type const& rhs);
00231 private:
00232 basic_findvolume_sequence_value_type(char_type const* vol_name);
00233 public:
00234
00236 class_type& operator =(class_type const& rhs);
00237
00238
00239 public:
00241 operator char_type const* () const
00242 {
00243 return m_name;
00244 }
00245
00246 private:
00247 friend class basic_findvolume_sequence_const_iterator<C, T, class_type>;
00248
00249 char_type m_name[MAX_VOL_NAME + 1];
00250 };
00251
00252
00257 template< ss_typename_param_k C
00258 , ss_typename_param_k T
00259 , ss_typename_param_k V
00260 >
00261 class basic_findvolume_sequence_const_iterator
00262 : public stlsoft_ns_qual(iterator_base)<
00263 winstl_ns_qual_std(input_iterator_tag)
00264 , V
00265 , ws_ptrdiff_t
00266 , void
00267 , V
00268 >
00269 {
00270 public:
00272 typedef C char_type;
00274 typedef T traits_type;
00276 typedef V value_type;
00278 typedef basic_findvolume_sequence_const_iterator<C, T, V> class_type;
00279
00282 private:
00283 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00284 struct shared_handle
00285 {
00286 public:
00287 typedef shared_handle class_type;
00288
00289
00290 public:
00291 HANDLE hSrch;
00292 private:
00293 ss_sint32_t cRefs;
00294
00295 public:
00296 ss_explicit_k shared_handle(HANDLE h)
00297 : hSrch(h)
00298 , cRefs(1)
00299 {}
00300 void AddRef()
00301 {
00302 ++cRefs;
00303 }
00304 void Release()
00305 {
00306 if(0 == --cRefs)
00307 {
00308 delete this;
00309 }
00310 }
00311 #if defined(STLSOFT_CF_COMPILER_WARNS_NO_PUBLIC_DTOR)
00312 protected:
00313 #else
00314 private:
00315 #endif
00316 ~shared_handle() stlsoft_throw_0()
00317 {
00318 WINSTL_MESSAGE_ASSERT("Shared search handle being destroyed with outstanding references!", 0 == cRefs);
00319
00320 if(hSrch != INVALID_HANDLE_VALUE)
00321 {
00322 traits_type::find_volume_close(hSrch);
00323 }
00324 }
00325
00326 private:
00327 shared_handle(class_type const&);
00328 class_type& operator =(class_type const&);
00329 };
00330 #endif
00332
00335 private:
00336 basic_findvolume_sequence_const_iterator(basic_findvolume_sequence<C, T> const& l, HANDLE hSrch, char_type const* vol_name)
00337 : m_list(&l)
00338 , m_handle(new shared_handle(hSrch))
00339 {
00340 WINSTL_ASSERT(INVALID_HANDLE_VALUE != hSrch);
00341
00342 if(NULL == m_handle)
00343 {
00344 traits_type::find_volume_close(hSrch);
00345 m_name[0] = '\0';
00346 }
00347 else
00348 {
00349 traits_type::char_copy(m_name, vol_name, STLSOFT_NUM_ELEMENTS(m_name));
00350 }
00351 }
00352 basic_findvolume_sequence_const_iterator(basic_findvolume_sequence<C, T> const& l);
00353 public:
00355 basic_findvolume_sequence_const_iterator();
00357 basic_findvolume_sequence_const_iterator(class_type const& rhs);
00359 ~basic_findvolume_sequence_const_iterator() stlsoft_throw_0();
00360
00362 class_type& operator =(class_type const& rhs);
00363
00364 public:
00366 class_type& operator ++();
00368 class_type operator ++(int);
00370 const value_type operator *() const;
00372 ws_bool_t operator ==(class_type const& rhs) const;
00374 ws_bool_t operator !=(class_type const& rhs) const;
00375
00376
00377 private:
00378 friend class basic_findvolume_sequence<C, T>;
00379
00380 typedef basic_findvolume_sequence<C, T> list_type;
00381
00382 list_type const* m_list;
00383 shared_handle* m_handle;
00384 char_type m_name[MAX_VOL_NAME + 1];
00385 };
00386
00388
00389
00390
00391
00392 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00393
00394 template <ss_typename_param_k T>
00395 inline ws_char_a_t const* c_str_data_a(winstl_ns_qual(basic_findvolume_sequence_value_type)<ws_char_a_t, T> const& v)
00396 {
00397 return v;
00398 }
00399 template <ss_typename_param_k T>
00400 inline ws_char_w_t const* c_str_data_w(winstl_ns_qual(basic_findvolume_sequence_value_type)<ws_char_w_t, T> const& v)
00401 {
00402 return v;
00403 }
00404
00405 #endif
00406
00411 template <ss_typename_param_k C, ss_typename_param_k T>
00412 inline C const* c_str_data(winstl_ns_qual(basic_findvolume_sequence_value_type)<C, T> const& v)
00413 {
00414 return v;
00415 }
00416
00417
00418
00419
00420 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00421
00422 template <ss_typename_param_k T>
00423 inline ws_size_t c_str_len_a(winstl_ns_qual(basic_findvolume_sequence_value_type)<ws_char_a_t, T> const& v)
00424 {
00425 return stlsoft_ns_qual(c_str_len_a(stlsoft_ns_qual(c_str_ptr_a(v))));
00426 }
00427 template <ss_typename_param_k T>
00428 inline ws_size_t c_str_len_w(winstl_ns_qual(basic_findvolume_sequence_value_type)<ws_char_w_t, T> const& v)
00429 {
00430 return stlsoft_ns_qual(c_str_len_w(stlsoft_ns_qual(c_str_ptr_w(v))));
00431 }
00432
00433 #endif
00434
00439 template <ss_typename_param_k C, ss_typename_param_k T>
00440 inline ws_size_t c_str_len(winstl_ns_qual(basic_findvolume_sequence_value_type)<C, T> const& v)
00441 {
00442 return stlsoft_ns_qual(c_str_len(stlsoft_ns_qual(c_str_ptr(v))));
00443 }
00444
00445
00446
00447
00448 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00449
00450 template <ss_typename_param_k T>
00451 inline ws_char_a_t const* c_str_ptr_a(winstl_ns_qual(basic_findvolume_sequence_value_type)<ws_char_a_t, T> const& v)
00452 {
00453 return v;
00454 }
00455 template <ss_typename_param_k T>
00456 inline ws_char_w_t const* c_str_ptr_w(winstl_ns_qual(basic_findvolume_sequence_value_type)<ws_char_w_t, T> const& v)
00457 {
00458 return v;
00459 }
00460
00461 #endif
00462
00467 template <ss_typename_param_k C, ss_typename_param_k T>
00468 inline C const* c_str_ptr(winstl_ns_qual(basic_findvolume_sequence_value_type)<C, T> const& v)
00469 {
00470 return v;
00471 }
00472
00473
00474
00475
00476 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00477
00478 template <ss_typename_param_k T>
00479 inline ws_char_a_t const* c_str_ptr_null_a(winstl_ns_qual(basic_findvolume_sequence_value_type)<ws_char_a_t, T> const& v)
00480 {
00481 return stlsoft_ns_qual(c_str_ptr_null_a(v));
00482 }
00483 template <ss_typename_param_k T>
00484 inline ws_char_w_t const* c_str_ptr_null_w(winstl_ns_qual(basic_findvolume_sequence_value_type)<ws_char_w_t, T> const& v)
00485 {
00486 return stlsoft_ns_qual(c_str_ptr_null_w(v));
00487 }
00488
00489 #endif
00490
00495 template <ss_typename_param_k C, ss_typename_param_k T>
00496 inline C const* c_str_ptr_null(winstl_ns_qual(basic_findvolume_sequence_value_type)<C, T> const& v)
00497 {
00498 return stlsoft_ns_qual(c_str_ptr_null(v));
00499 }
00500
00501
00502
00503
00504
00505
00506 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00507
00508 template <ss_typename_param_k C, ss_typename_param_k T>
00509 inline ws_bool_t is_empty(winstl_ns_qual(basic_findvolume_sequence_value_type)<C, T> const& v)
00510 {
00511 return '\0' == v[0];
00512 }
00513
00514 #endif
00515
00517
00518
00519 #ifdef STLSOFT_UNITTEST
00520 # include "./unittest/findvolume_sequence_unittest_.h"
00521 #endif
00522
00524
00525
00526 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00527
00528
00529
00530 template <ss_typename_param_k C, ss_typename_param_k T>
00531 inline ss_typename_type_ret_k basic_findvolume_sequence<C, T>::const_iterator basic_findvolume_sequence<C, T>::begin() const
00532 {
00533 char_type vol_name[MAX_VOL_NAME + 1];
00534 HANDLE hSrch = traits_type::find_first_volume(vol_name, STLSOFT_NUM_ELEMENTS(vol_name));
00535
00536 if(hSrch != INVALID_HANDLE_VALUE)
00537 {
00538 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
00539 try
00540 {
00541 #endif
00542 return const_iterator(*this, hSrch, vol_name);
00543 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
00544 }
00545 catch(...)
00546 {
00547 traits_type::find_volume_close(hSrch);
00548
00549 throw;
00550 }
00551 #endif
00552 }
00553
00554 return const_iterator(*this);
00555 }
00556
00557 template <ss_typename_param_k C, ss_typename_param_k T>
00558 inline ss_typename_type_ret_k basic_findvolume_sequence<C, T>::const_iterator basic_findvolume_sequence<C, T>::end() const
00559 {
00560 return const_iterator(*this);
00561 }
00562
00563 template <ss_typename_param_k C, ss_typename_param_k T>
00564 inline ws_bool_t basic_findvolume_sequence<C, T>::empty() const
00565 {
00566 return begin() == end();
00567 }
00568
00569
00570
00571 template <ss_typename_param_k C, ss_typename_param_k T>
00572 inline basic_findvolume_sequence_value_type<C, T>::basic_findvolume_sequence_value_type()
00573 {
00574 m_name[0] = '\0';
00575 }
00576
00577 template <ss_typename_param_k C, ss_typename_param_k T>
00578 inline basic_findvolume_sequence_value_type<C, T>::basic_findvolume_sequence_value_type(class_type const& rhs)
00579 {
00580 traits_type::char_copy(m_name, rhs.m_name, STLSOFT_NUM_ELEMENTS(m_name));
00581 }
00582
00583 template <ss_typename_param_k C, ss_typename_param_k T>
00584 inline basic_findvolume_sequence_value_type<C, T>::basic_findvolume_sequence_value_type(char_type const* vol_name)
00585 {
00586 traits_type::char_copy(m_name, vol_name, STLSOFT_NUM_ELEMENTS(m_name));
00587 }
00588
00589 template <ss_typename_param_k C, ss_typename_param_k T>
00590 inline ss_typename_type_ret_k basic_findvolume_sequence_value_type<C, T>::class_type& basic_findvolume_sequence_value_type<C, T>::operator =(class_type const& rhs)
00591 {
00592 traits_type::char_copy(m_name, rhs.m_name, STLSOFT_NUM_ELEMENTS(m_name));
00593
00594 return *this;
00595 }
00596
00597
00598
00599
00600 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V>
00601 inline basic_findvolume_sequence_const_iterator<C, T, V>::basic_findvolume_sequence_const_iterator()
00602 : m_list(NULL)
00603 , m_handle(NULL)
00604 {
00605 m_name[0] = '\0';
00606 }
00607
00608 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V>
00609 inline basic_findvolume_sequence_const_iterator<C, T, V>::basic_findvolume_sequence_const_iterator(basic_findvolume_sequence<C, T> const& l)
00610 : m_list(&l)
00611 , m_handle(NULL)
00612 {
00613 m_name[0] = '\0';
00614 }
00615
00616 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V>
00617 inline basic_findvolume_sequence_const_iterator<C, T, V>::basic_findvolume_sequence_const_iterator(class_type const& rhs)
00618 : m_list(rhs.m_list)
00619 , m_handle(rhs.m_handle)
00620 {
00621 if(NULL != m_handle)
00622 {
00623 m_handle->AddRef();
00624 }
00625 }
00626
00627 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00628
00629 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V>
00630 inline ss_typename_type_ret_k basic_findvolume_sequence_const_iterator<C, T, V>::class_type& basic_findvolume_sequence_const_iterator<C, T, V>::operator =(ss_typename_type_k basic_findvolume_sequence_const_iterator<C, T, V>::class_type const& rhs)
00631 {
00632 shared_handle *this_handle = m_handle;
00633
00634 m_list = rhs.m_list;
00635 m_handle = rhs.m_handle;
00636
00637 if(NULL != m_handle)
00638 {
00639 m_handle->AddRef();
00640 }
00641
00642 if(NULL != this_handle)
00643 {
00644 this_handle->Release();
00645 }
00646
00647 return *this;
00648 }
00649
00650 #endif
00651
00652 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V>
00653 inline basic_findvolume_sequence_const_iterator<C, T, V>::~basic_findvolume_sequence_const_iterator() stlsoft_throw_0()
00654 {
00655 if(NULL != m_handle)
00656 {
00657 m_handle->Release();
00658 }
00659 }
00660
00661 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V>
00662 inline ss_typename_type_ret_k basic_findvolume_sequence_const_iterator<C, T, V>::class_type& basic_findvolume_sequence_const_iterator<C, T, V>::operator ++()
00663 {
00664 WINSTL_MESSAGE_ASSERT("Attempting to increment an invalid iterator!", NULL != m_handle);
00665
00666 if(!traits_type::find_next_volume(m_handle->hSrch, m_name, STLSOFT_NUM_ELEMENTS(m_name)))
00667 {
00668 m_handle->Release();
00669
00670 m_handle = NULL;
00671 }
00672
00673 return *this;
00674 }
00675
00676 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V>
00677 inline ss_typename_type_ret_k basic_findvolume_sequence_const_iterator<C, T, V>::class_type basic_findvolume_sequence_const_iterator<C, T, V>::operator ++(int)
00678 {
00679 class_type ret(*this);
00680
00681 operator ++();
00682
00683 return ret;
00684 }
00685
00686 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V>
00687 inline const ss_typename_type_k basic_findvolume_sequence_const_iterator<C, T, V>::value_type basic_findvolume_sequence_const_iterator<C, T, V>::operator *() const
00688 {
00689 if(NULL != m_handle)
00690 {
00691 return value_type(m_name);
00692 }
00693 else
00694 {
00695 return value_type();
00696 }
00697 }
00698
00699 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V>
00700 inline ws_bool_t basic_findvolume_sequence_const_iterator<C, T, V>::operator ==(class_type const& rhs) const
00701 {
00702 WINSTL_MESSAGE_ASSERT("Comparing iterators from separate sequences", (m_list == rhs.m_list || NULL == m_list || NULL == rhs.m_list));
00703
00704 return m_handle == rhs.m_handle;
00705 }
00706
00707 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V>
00708 inline ws_bool_t basic_findvolume_sequence_const_iterator<C, T, V>::operator !=(class_type const& rhs) const
00709 {
00710 return ! operator ==(rhs);
00711 }
00712
00713 #endif
00714
00715
00716
00717 #ifndef _WINSTL_NO_NAMESPACE
00718 # if defined(_STLSOFT_NO_NAMESPACE) || \
00719 defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
00720 }
00721 # else
00722 }
00723 }
00724 # endif
00725 #endif
00726
00727
00728
00729
00730
00731
00732
00733
00734
00735 #ifndef _WINSTL_NO_NAMESPACE
00736 # if !defined(_STLSOFT_NO_NAMESPACE) && \
00737 !defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
00738 namespace stlsoft
00739 {
00740 # else
00741
00742 # endif
00743
00744 using ::winstl::c_str_len;
00745 using ::winstl::c_str_len_a;
00746 using ::winstl::c_str_len_w;
00747
00748 using ::winstl::c_str_data;
00749 using ::winstl::c_str_data_a;
00750 using ::winstl::c_str_data_w;
00751
00752 using ::winstl::c_str_ptr;
00753 using ::winstl::c_str_ptr_a;
00754 using ::winstl::c_str_ptr_w;
00755
00756 using ::winstl::c_str_ptr_null;
00757
00758
00759
00760 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00761
00762 using ::winstl::is_empty;
00763
00764 #endif
00765
00766 # if !defined(_STLSOFT_NO_NAMESPACE) && \
00767 !defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
00768 }
00769 # else
00770
00771 # endif
00772 #endif
00773
00774
00775
00776 #endif
00777
00778