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
00050 #ifndef ATLSTL_INCL_ATLSTL_AUTOMATION_HPP_ENUMERATORS
00051 #define ATLSTL_INCL_ATLSTL_AUTOMATION_HPP_ENUMERATORS
00052
00053 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00054 # define ATLSTL_VER_ATLSTL_AUTOMATION_HPP_ENUMERATORS_MAJOR 4
00055 # define ATLSTL_VER_ATLSTL_AUTOMATION_HPP_ENUMERATORS_MINOR 0
00056 # define ATLSTL_VER_ATLSTL_AUTOMATION_HPP_ENUMERATORS_REVISION 5
00057 # define ATLSTL_VER_ATLSTL_AUTOMATION_HPP_ENUMERATORS_EDIT 67
00058 #endif
00059
00061
00062
00063 #ifndef ATLSTL_INCL_ATLSTL_HPP_ATLSTL
00064 # include <atlstl/atlstl.hpp>
00065 #endif
00066 #ifndef STLSOFT_INCL_STLSOFT_SMARTPTR_HPP_REF_PTR
00067 # include <stlsoft/smartptr/ref_ptr.hpp>
00068 #endif
00069 #ifndef STLSOFT_INCL_STLSOFT_FUNCTIONAL_HPP_INDIRECT_FUNCTION_POINTER_ADAPTORS
00070 # include <stlsoft/functional/indirect_function_pointer_adaptors.hpp>
00071 #endif
00072
00073 #ifndef STLSOFT_INCL_SYS_H_ATLCOM
00074 # define STLSOFT_INCL_SYS_H_ATLCOM
00075 # include <atlcom.h>
00076 #endif
00077 #ifndef STLSOFT_INCL_ALGORITHM
00078 # define STLSOFT_INCL_ALGORITHM
00079 # include <algorithm>
00080 #endif
00081 #ifndef STLSOFT_INCL_LIST
00082 # define STLSOFT_INCL_LIST
00083 # include <list>
00084 #endif
00085
00086
00087
00088
00089
00090 #ifndef _ATLSTL_NO_NAMESPACE
00091 # if defined(_STLSOFT_NO_NAMESPACE) || \
00092 defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
00093
00094 namespace atlstl
00095 {
00096 # else
00097
00098
00099 namespace stlsoft
00100 {
00101
00102 namespace atlstl_project
00103 {
00104
00105 # endif
00106 #endif
00107
00108
00109
00110
00111
00115 template< ss_typename_param_k XV
00116 , ss_typename_param_k IV
00117 >
00118 struct copy_policy
00119 {
00120 public:
00121 typedef XV external_value_type;
00122 typedef IV internal_value_type;
00123
00124 public:
00125 static void init(external_value_type *xv);
00126 #if 0
00127 {
00128 *xv = external_value_type();
00129 }
00130 #endif
00131 static HRESULT copy(external_value_type *xv, internal_value_type const& iv);
00132 #if 0
00133 {
00134 *xv = iv;
00135
00136 return S_OK;
00137 }
00138 #endif
00140 static void clear(external_value_type *xv);
00141 #if 0
00142 {
00143 STLSOFT_SUPPRESS_UNUSED(xv);
00144 }
00145 #endif
00146 };
00147
00149
00150
00151
00176 template< ss_typename_param_k I
00177 , IID const* piid
00178 , ss_typename_param_k V
00179 , ss_typename_param_k IV = V
00180 , ss_typename_param_k I2ETx = copy_policy<IV, V>
00181 , ss_typename_param_k TM = CComObjectThreadModel
00182 >
00183 class ATL_NO_VTABLE copy_enumerator
00184 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00185 ;
00186
00187
00188
00189 template< ss_typename_param_k I
00190 , IID const* piid
00191 , ss_typename_param_k V
00192 , ss_typename_param_k IV
00193 , ss_typename_param_k I2ETx
00194 >
00195 class ATL_NO_VTABLE copy_enumerator_impl
00196 : public I
00197 {
00200 public:
00201 typedef I interface_type;
00202 typedef V value_type;
00203 typedef IV internal_value_type;
00204 typedef I2ETx internal_to_external_transformer_type;
00205
00206 typedef copy_enumerator_impl<I, piid, V, IV, I2ETx> class_type;
00207 typedef ss_size_t size_type;
00208 typedef ss_ptrdiff_t difference_type;
00209 private:
00210 typedef stlsoft_ns_qual_std(list)<internal_value_type> values_type;
00211 public:
00212 typedef ss_typename_type_k values_type::iterator iterator;
00213 typedef ss_typename_type_k values_type::const_iterator const_iterator;
00215
00218 public:
00219 copy_enumerator_impl();
00220 ~copy_enumerator_impl() stlsoft_throw_0();
00222
00225 public:
00226 STDMETHOD(Next)(ULONG celt, V *rgelt, ULONG *pceltFetched);
00227 STDMETHOD(Skip)(ULONG celt);
00228 STDMETHOD(Reset)(void);
00229 STDMETHOD(Clone)(I **ppEnum);
00231
00234 public:
00235 template<ss_typename_param_k I, ss_typename_param_k F>
00236 HRESULT Init(I begin, I end, F fn)
00237 {
00238 # ifdef STLSOFT_CF_EXCEPTION_SUPPORT
00239 try
00240 {
00241 # endif
00242 m_values.clear();
00243
00244 for(; begin != end; ++begin)
00245 {
00246 m_values.push_back(fn(*begin));
00247 }
00248
00249 m_current = m_values.begin();
00250
00251 return S_OK;
00252 # ifdef STLSOFT_CF_EXCEPTION_SUPPORT
00253 }
00254 catch(std::bad_alloc &)
00255 {
00256 return E_OUTOFMEMORY;
00257 }
00258 catch(std::exception &)
00259 {
00260 return E_UNEXPECTED;
00261 }
00262 # endif
00263 }
00264 template<ss_typename_param_k I>
00265 HRESULT Init(I begin, I end)
00266 {
00267 # ifdef STLSOFT_CF_EXCEPTION_SUPPORT
00268 try
00269 {
00270 # endif
00271 m_values.clear();
00272
00273 for(; begin != end; ++begin)
00274 {
00275 m_values.push_back(*begin);
00276 }
00277
00278 m_current = m_values.begin();
00279
00280 return S_OK;
00281 # ifdef STLSOFT_CF_EXCEPTION_SUPPORT
00282 }
00283 catch(std::bad_alloc &)
00284 {
00285 return E_OUTOFMEMORY;
00286 }
00287 catch(std::exception &)
00288 {
00289 return E_UNEXPECTED;
00290 }
00291 # endif
00292 }
00293
00294 size_type size() const;
00295
00296 const_iterator begin() const;
00297 iterator begin();
00298
00299 const_iterator end() const;
00300 iterator end();
00302
00305 private:
00306 virtual class_type *CreateEmptyClone() const = 0;
00307
00308 template <typename T>
00309 static difference_type count_all(T const& b, T const& e)
00310 {
00311 difference_type d = 0;
00312 T begin = b;
00313 T end = e;
00314
00315 for(; begin != end; ++begin)
00316 {
00317 ++d;
00318 }
00319
00320 return d;
00321 }
00322
00323 template <typename T>
00324 static T increment_by(T it, difference_type by)
00325 {
00326 for(; by-- > 0; )
00327 {
00328 ++it;
00329 }
00330
00331 return it;
00332 }
00334
00337 private:
00338 values_type m_values;
00339 const_iterator m_current;
00341
00344 private:
00345 copy_enumerator_impl(class_type const&);
00346 class_type& operator =(class_type const&);
00348 };
00349
00350 # if defined(STLSOFT_COMPILER_IS_INTEL) || \
00351 defined(STLSOFT_COMPILER_IS_MSVC)
00352 # if _MSC_VER >= 1200
00353 # pragma warning(push)
00354 # endif
00355 # pragma warning(disable : 4348)
00356 # endif
00357
00358
00359
00360 template< ss_typename_param_k I
00361 , IID const* piid
00362 , ss_typename_param_k V
00363 , ss_typename_param_k IV = V
00364 , ss_typename_param_k I2ETx = copy_policy<IV, V>
00365 , ss_typename_param_k TM = CComObjectThreadModel
00366 >
00367 class ATL_NO_VTABLE copy_enumerator
00368 : public copy_enumerator_impl<I, piid, V, IV, I2ETx>
00369 , public CComObjectRootEx<TM>
00370 #endif
00371 {
00372 public:
00373 typedef copy_enumerator<I, piid, V, IV, I2ETx, TM> class_type;
00374 private:
00375 typedef copy_enumerator_impl<I, piid, V, IV, I2ETx> impl_type_;
00376
00377 public:
00378 BEGIN_COM_MAP(class_type)
00379 COM_INTERFACE_ENTRY_IID(*piid, impl_type_)
00380 END_COM_MAP()
00381
00382 protected:
00383 virtual impl_type_ *CreateEmptyClone() const
00384 {
00385 return new CComObject<class_type>;
00386 }
00387 };
00388
00389 #if defined(STLSOFT_COMPILER_IS_INTEL) || \
00390 defined(STLSOFT_COMPILER_IS_MSVC)
00391 # if _MSC_VER >= 1200
00392 # pragma warning(pop)
00393 # else
00394 # pragma warning(default: 4348)
00395 # endif
00396 #endif
00397
00399
00400
00401 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00402
00403 template< ss_typename_param_k I
00404 , IID const* piid
00405 , ss_typename_param_k V
00406 , ss_typename_param_k IV
00407 , ss_typename_param_k I2ETx
00408 >
00409 inline copy_enumerator_impl<I, piid, V, IV, I2ETx>::copy_enumerator_impl()
00410 : m_values()
00411 , m_current(m_values.begin())
00412 {}
00413
00414 template< ss_typename_param_k I
00415 , IID const* piid
00416 , ss_typename_param_k V
00417 , ss_typename_param_k IV
00418 , ss_typename_param_k I2ETx
00419 >
00420 inline copy_enumerator_impl<I, piid, V, IV, I2ETx>::~copy_enumerator_impl() stlsoft_throw_0()
00421 {}
00422
00423 template< ss_typename_param_k I
00424 , IID const* piid
00425 , ss_typename_param_k V
00426 , ss_typename_param_k IV
00427 , ss_typename_param_k I2ETx
00428 >
00429 inline STDMETHODIMP copy_enumerator_impl<I, piid, V, IV, I2ETx>::Next(ULONG celt, V *rgelt, ULONG *pceltFetched)
00430 {
00431 HRESULT hr;
00432
00433 if( rgelt == NULL ||
00434 ( celt != 1 &&
00435 pceltFetched == NULL))
00436 {
00437 hr = E_POINTER;
00438 }
00439 else
00440 {
00441 ULONG celtFetched_;
00442
00443 if(NULL == pceltFetched)
00444 {
00445 pceltFetched = &celtFetched_;
00446 }
00447
00448 { for(*pceltFetched = 0, hr = S_OK; celt > 0 && m_current != m_values.end(); --celt, ++m_current, ++rgelt, ++*pceltFetched)
00449 {
00450 internal_to_external_transformer_type::init(rgelt);
00451 hr = internal_to_external_transformer_type::copy(rgelt, *m_current);
00452
00453 if(FAILED(hr))
00454 {
00455 break;
00456 }
00457 }}
00458
00459 if(FAILED(hr))
00460 {
00461 for(; 0 != *pceltFetched; --*pceltFetched)
00462 {
00463 internal_to_external_transformer_type::clear(--rgelt);
00464 }
00465 }
00466
00467 if(SUCCEEDED(hr))
00468 {
00469 hr = (0 == celt) ? S_OK : S_FALSE;
00470 }
00471 }
00472
00473 return hr;
00474 }
00475
00476 template< ss_typename_param_k I
00477 , IID const* piid
00478 , ss_typename_param_k V
00479 , ss_typename_param_k IV
00480 , ss_typename_param_k I2ETx
00481 >
00482 inline STDMETHODIMP copy_enumerator_impl<I, piid, V, IV, I2ETx>::Skip(ULONG celt)
00483 {
00484 { for(; celt > 0 && m_current == m_values.end(); --celt, ++m_current)
00485 {
00486 }}
00487
00488 return (0 == celt) ? S_OK : S_FALSE;
00489 }
00490
00491 template< ss_typename_param_k I
00492 , IID const* piid
00493 , ss_typename_param_k V
00494 , ss_typename_param_k IV
00495 , ss_typename_param_k I2ETx
00496 >
00497 inline STDMETHODIMP copy_enumerator_impl<I, piid, V, IV, I2ETx>::Reset(void)
00498 {
00499 m_current = m_values.begin();
00500
00501 return S_OK;
00502 }
00503
00504 template< ss_typename_param_k I
00505 , IID const* piid
00506 , ss_typename_param_k V
00507 , ss_typename_param_k IV
00508 , ss_typename_param_k I2ETx
00509 >
00510 inline STDMETHODIMP copy_enumerator_impl<I, piid, V, IV, I2ETx>::Clone(I** ppEnum)
00511 {
00512 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
00513 try
00514 {
00515 #endif
00516 if(NULL == ppEnum)
00517 {
00518 return E_POINTER;
00519 }
00520 else
00521 {
00522 *ppEnum = NULL;
00523
00524 HRESULT hr;
00525 class_type *pThis = this;
00526 class_type *p = pThis->CreateEmptyClone();
00527
00528 if(p == NULL)
00529 {
00530 hr = E_OUTOFMEMORY;
00531 }
00532 else
00533 {
00534 stlsoft::ref_ptr<class_type, I> en(p, true);
00535
00536 hr = p->Init(this->begin(), this->end());
00537
00538 if(SUCCEEDED(hr))
00539 {
00540 const_iterator begin = this->m_values.begin();
00541 const_iterator current = this->m_current;
00542
00543 std::advance(p->m_current, std::distance(begin, current));
00544
00545 hr = en->QueryInterface(*piid, reinterpret_cast<void**>(ppEnum));
00546 }
00547 }
00548
00549 return hr;
00550 }
00551 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
00552 }
00553 catch(std::bad_alloc &)
00554 {
00555 return E_OUTOFMEMORY;
00556 }
00557 catch(std::exception &)
00558 {
00559 return E_UNEXPECTED;
00560 }
00561 #endif
00562 }
00563
00564 template< ss_typename_param_k I
00565 , IID const* piid
00566 , ss_typename_param_k V
00567 , ss_typename_param_k IV
00568 , ss_typename_param_k I2ETx
00569 >
00570 inline ss_size_t copy_enumerator_impl<I, piid, V, IV, I2ETx>::size() const
00571 {
00572 return m_values.size();
00573 }
00574
00575 template< ss_typename_param_k I
00576 , IID const* piid
00577 , ss_typename_param_k V
00578 , ss_typename_param_k IV
00579 , ss_typename_param_k I2ETx
00580 >
00581 inline ss_typename_type_ret_k copy_enumerator_impl<I, piid, V, IV, I2ETx>::const_iterator copy_enumerator_impl<I, piid, V, IV, I2ETx>::begin() const
00582 {
00583 return m_values.begin();
00584 }
00585
00586 template< ss_typename_param_k I
00587 , IID const* piid
00588 , ss_typename_param_k V
00589 , ss_typename_param_k IV
00590 , ss_typename_param_k I2ETx
00591 >
00592 inline ss_typename_type_ret_k copy_enumerator_impl<I, piid, V, IV, I2ETx>::iterator copy_enumerator_impl<I, piid, V, IV, I2ETx>::begin()
00593 {
00594 return m_values.begin();
00595 }
00596
00597 template< ss_typename_param_k I
00598 , IID const* piid
00599 , ss_typename_param_k V
00600 , ss_typename_param_k IV
00601 , ss_typename_param_k I2ETx
00602 >
00603 inline ss_typename_type_ret_k copy_enumerator_impl<I, piid, V, IV, I2ETx>::const_iterator copy_enumerator_impl<I, piid, V, IV, I2ETx>::end() const
00604 {
00605 return m_values.end();
00606 }
00607
00608 template< ss_typename_param_k I
00609 , IID const* piid
00610 , ss_typename_param_k V
00611 , ss_typename_param_k IV
00612 , ss_typename_param_k I2ETx
00613 >
00614 inline ss_typename_type_ret_k copy_enumerator_impl<I, piid, V, IV, I2ETx>::iterator copy_enumerator_impl<I, piid, V, IV, I2ETx>::end()
00615 {
00616 return m_values.end();
00617 }
00618
00619 #endif
00620
00621
00622
00623 #ifndef _ATLSTL_NO_NAMESPACE
00624 # if defined(_STLSOFT_NO_NAMESPACE) || \
00625 defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
00626 }
00627 # else
00628 }
00629 }
00630 # endif
00631 #endif
00632
00633
00634
00635 #endif
00636
00637