XTPSmartPtrInternalT.h
上传用户:szled88
上传日期:2015-04-09
资源大小:43957k
文件大小:31k
源码类别:

对话框与窗口

开发平台:

Visual C++

  1. // XTPSmartPtrInternalT.h: CXTPSmartPtrInternalT template definition.
  2. //
  3. // This file is a part of the XTREME TOOLKIT PRO MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  20. //{{AFX_CODEJOCK_PRIVATE
  21. #if !defined(_XtpSmartPtrInternal_H__)
  22. #define _XtpSmartPtrInternal_H__
  23. #if _MSC_VER > 1000
  24. #pragma once
  25. #endif // _MSC_VER > 1000
  26. //}}AFX_CODEJOCK_PRIVATE
  27. /////////////////////////////////////////////////////////////////////////////
  28. // template: CXTPSmartPtrInternalT
  29. // macro:    XTP_DEFINE_SMART_PTR_INTERNAL(_TClassName)
  30. //           XTP_DEFINE_SMART_PTR_ARRAY_INTERNAL(_TClassName)
  31. /////////////////////////////////////////////////////////////////////////////
  32. // -----------------------------------------------------------------------
  33. // Parameters:
  34. //     ClassName :  Name of the class used to define the smart pointer.
  35. // Remarks:
  36. //     Define smart pointer for the specified class as ClassNamePtr.
  37. //     CXTPSmartPtrInternalT is used for this purpose.
  38. // For example: XTP_DEFINE_SMART_PTR_INTERNAL(CCmdTarget) will be replaced
  39. //     to: typedef CXTPSmartPtrInternalT<CCmdTarget> CCmdTargetPtr;
  40. // -----------------------------------------------------------------------
  41. #define XTP_DEFINE_SMART_PTR_INTERNAL(ClassName) 
  42. typedef CXTPSmartPtrInternalT<ClassName> ClassName##Ptr;
  43. // -----------------------------------------------------------------------
  44. // Parameters:
  45. //     ClassName :  Name of the class used to define the array of smart pointers.
  46. // Remarks:
  47. //     Define smart pointers array for the specified class as ClassNamePtrArray.
  48. //     CXTPInternalCollectionT is used for this purpose.
  49. //     Also define smart pointer for array as ClassNamePtrArrayPtr.
  50. // -----------------------------------------------------------------------
  51. #define XTP_DEFINE_SMART_PTR_ARRAY_INTERNAL(ClassName) 
  52. typedef CXTPInternalCollectionT<ClassName> ClassName##PtrArray; 
  53. typedef CXTPSmartPtrInternalT<ClassName> ClassName##PtrArrayPtr;
  54. //===========================================================================
  55. // Remarks:
  56. //     This internal class is used for semi-automatic incrementing
  57. //          and decrementing reference to any object derived from CCmdTarget
  58. //          or other class, which has InternalAddRef(), InternalRelease()
  59. //          methods.
  60. // See Also: macro XTP_DEFINE_SMART_PTR_INTERNAL(_TClassName)
  61. //===========================================================================
  62. template<class _TObject>
  63. class CXTPSmartPtrInternalT
  64. {
  65. protected:
  66. //------------------------------------------------------------------------
  67. // Remarks:
  68. //     This class type definition
  69. //------------------------------------------------------------------------
  70. typedef CXTPSmartPtrInternalT<_TObject> Tthis;
  71. _TObject* m_pObject; // A pointer to a handled object
  72. public:
  73. //-----------------------------------------------------------------------
  74. // Parameters:
  75. //     pObject             - Pointer to the handled object.
  76. //     bCallInternalAddRef - If this parameter is TRUE
  77. //                                pObject->InternalAddRef() will be
  78. //                                called in constructor.
  79. //                                By default this parameter is FALSE.
  80. // Summary:
  81. //     Default class constructor.
  82. // See Also: ~CXTPSmartPtrInternalT()
  83. //-----------------------------------------------------------------------
  84. CXTPSmartPtrInternalT(_TObject* pObject = NULL, BOOL bCallInternalAddRef = FALSE)
  85. {
  86. m_pObject = pObject;
  87. if (bCallInternalAddRef && m_pObject) {
  88. ((CCmdTarget*)m_pObject)->InternalAddRef();
  89. }
  90. };
  91. //-----------------------------------------------------------------------
  92. // Summary:
  93. //     Copy class constructor.
  94. // See Also:
  95. //      CXTPSmartPtrInternalT(_TObject* pObject, BOOL bCallInternalAddRef)
  96. // Parameters:
  97. //     rSrc :  the source object reference.
  98. //-----------------------------------------------------------------------
  99. CXTPSmartPtrInternalT(const Tthis& rSrc)
  100. {
  101. m_pObject = (_TObject*)rSrc;
  102. if (m_pObject) {
  103. ((CCmdTarget*)m_pObject)->InternalAddRef();
  104. }
  105. };
  106. //-----------------------------------------------------------------------
  107. // Summary:
  108. //     Default class destructor.
  109. // Remarks:
  110. //     Call InternalRelease() for the not NULL handled object.
  111. // See Also: CXTPSmartPtrInternalT constructors
  112. //-----------------------------------------------------------------------
  113. virtual ~CXTPSmartPtrInternalT() {
  114. if (m_pObject) {
  115. ((CCmdTarget*)m_pObject)->InternalRelease();
  116. }
  117. };
  118. //-----------------------------------------------------------------------
  119. // Summary:
  120. //     Set new handled object.
  121. // Parameters:
  122. //     rSrc                 - Pointer to the new handled object.
  123. //     bCallInternalAddRef - If this parameter is TRUE
  124. //                           pObject->InternalAddRef() will be
  125. //                           called in constructor.
  126. //                           By default this parameter is FALSE.
  127. // Remarks:
  128. //     InternalRelease() for the previous not NULL handled object
  129. //     will be called. InternalAddRef() for the new not NULL handled
  130. //     object will be called.
  131. // See Also:
  132. //     operator=
  133. //-----------------------------------------------------------------------
  134. void SetPtr(_TObject* pObject, BOOL bCallInternalAddRef = FALSE)
  135. {
  136. _TObject* pObjOld = m_pObject;
  137. if (bCallInternalAddRef && pObject) {
  138. ((CCmdTarget*)pObject)->InternalAddRef();
  139. }
  140. m_pObject = pObject;
  141. if (pObjOld) {
  142. ((CCmdTarget*)pObjOld)->InternalRelease();
  143. }
  144. };
  145. //-----------------------------------------------------------------------
  146. // Summary:
  147. //     Get a handled object and set internal object member to NULL
  148. //          without call InternalRelease().
  149. // Returns:
  150. //     Pointer to the handled object.
  151. //-----------------------------------------------------------------------
  152. _TObject* Detach() {
  153. _TObject* pObj = m_pObject;
  154. m_pObject = NULL;
  155. return pObj;
  156. };
  157. //-----------------------------------------------------------------------
  158. // Summary:
  159. //     Get a handled object and set internal object member to NULL
  160. //          without call InternalRelease().
  161. // Returns:
  162. //     Pointer to the handled object.
  163. //-----------------------------------------------------------------------
  164. _TObject* GetInterface(BOOL bWithAddRef = TRUE) {
  165. if (bWithAddRef && m_pObject) {
  166. ((CCmdTarget*)m_pObject)->InternalAddRef();
  167. }
  168. return m_pObject;
  169. };
  170. //-----------------------------------------------------------------------
  171. // Parameters:
  172. //     pNewObj  - Pointer to the new handled object.
  173. // Summary:
  174. //     Set new handled object.
  175. // Remarks:
  176. //     InternalRelease() for the previous not NULL handled object
  177. //          will be called.
  178. // Returns:
  179. //     Pointer to the new handled object.
  180. //-----------------------------------------------------------------------
  181. _TObject* operator=(_TObject* pNewObj)
  182. {
  183. _TObject* pObjOld = m_pObject;
  184. m_pObject = pNewObj;
  185. if (pObjOld) {
  186. ((CCmdTarget*)pObjOld)->InternalRelease();
  187. }
  188. return pNewObj;
  189. };
  190. //-----------------------------------------------------------------------
  191. // Parameters:
  192. //     rSrc - Reference to the new handled object.
  193. // Summary:
  194. //     Set new handled object.
  195. // Remarks:
  196. //     InternalRelease() for the previous not NULL handled object
  197. //          will be called. InternalAddRef() for the new not NULL handled
  198. //          object will be called.
  199. // Returns:
  200. //     Reference to this class instance.
  201. //-----------------------------------------------------------------------
  202. const Tthis& operator=(const Tthis& rSrc) {
  203. _TObject* pObjOld = m_pObject;
  204. m_pObject = rSrc;
  205. if (m_pObject) {
  206. ((CCmdTarget*)m_pObject)->InternalAddRef();
  207. }
  208. if (pObjOld) {
  209. ((CCmdTarget*)pObjOld)->InternalRelease();
  210. }
  211. return rSrc;
  212. };
  213. //-----------------------------------------------------------------------
  214. // Summary:
  215. //     Get a handled object.
  216. // Returns:
  217. //     Pointer to the handled object.
  218. //-----------------------------------------------------------------------
  219. _TObject* operator->() const{
  220. ASSERT(m_pObject);
  221. return m_pObject;
  222. };
  223. //-----------------------------------------------------------------------
  224. // Summary:
  225. //     Get a handled object.
  226. // Returns:
  227. //     Pointer to the handled object.
  228. //-----------------------------------------------------------------------
  229. operator _TObject*() const {
  230. return m_pObject;
  231. }
  232. //-----------------------------------------------------------------------
  233. // Summary:
  234. //     Check is handled object equal NULL.
  235. // Returns:
  236. //     TRUE if handled object equal NULL, else FALSE.
  237. //-----------------------------------------------------------------------
  238. BOOL operator!() const {
  239. return !m_pObject;
  240. }
  241. //-----------------------------------------------------------------------
  242. // Summary:
  243. //     Equal-to operator.
  244. // Parameters:
  245. //      pObj :  [in] Pointer to the other object.
  246. //      ptr2 :  [in] Smart pointer to the other object.
  247. // Remarks:
  248. //     This operator compare internal stored pointer and specified
  249. //          pointer.
  250. // Returns:
  251. //     TRUE if pointer are equal, else FALSE.
  252. //-----------------------------------------------------------------------
  253. BOOL operator==(const _TObject* pObj) const {
  254. return pObj == m_pObject;
  255. }
  256. // <COMBINE operator==>
  257. BOOL operator==(const Tthis& ptr2) const {
  258. return m_pObject == (_TObject*)ptr2;
  259. }
  260. };
  261. //===========================================================================
  262. // Remarks:
  263. //      This internal class is used as collection for pointers of objects,
  264. //      derived from CCmdTarget or other class, which has InternalAddRef(),
  265. //      InternalRelease() methods. InternalAddRef() is called for stored
  266. //      object. InternalRelease() is called when object is removed.
  267. //      Also this collection object derived from IXTPInternalUnknown.
  268. // See Also:
  269. //      CXTPSmartPtrInternalT, CXTPInternalUnknown
  270. //===========================================================================
  271. template<class _TObject>
  272. class CXTPInternalCollectionT : public CArray<CXTPSmartPtrInternalT<_TObject>,
  273.   const CXTPSmartPtrInternalT<_TObject>& >
  274. {
  275. public:
  276. //------------------------------------------------------------------------
  277. // Remarks:
  278. //      Stored objects type definition.
  279. //------------------------------------------------------------------------
  280. typedef _TObject                        TObject;
  281. //------------------------------------------------------------------------
  282. // Remarks:
  283. //      Stored objects smart-pointer type definition.
  284. //------------------------------------------------------------------------
  285. typedef CXTPSmartPtrInternalT<_TObject> TObjectPtr;
  286. //--------------------------------------------------------------------
  287. // Summary:
  288. //      Default object constructor.
  289. //--------------------------------------------------------------------
  290. CXTPInternalCollectionT(){};
  291. //--------------------------------------------------------------------
  292. // Summary:
  293. //      Default object destructor.
  294. //--------------------------------------------------------------------
  295. virtual ~CXTPInternalCollectionT(){};
  296. /*
  297. //--------------------------------------------------------------------
  298. // Summary:
  299. //      Get pointer to this object.
  300. // Parameters:
  301. //      bWithAddRef : [in]  If TRUE - InternalAddRef() is called before
  302. //                          returning pointer. It is TRUE by default.
  303. // Returns:
  304. //      Pointer to this object.
  305. // Remarks:
  306. //      This function gets pointer to this object and calls
  307. //      InternalAddRef() if specified.
  308. // See also:
  309. //      IXTPInternalUnknown.
  310. //--------------------------------------------------------------------
  311. CXTPInternalCollectionT<_TObject>* GetInterface(BOOL bWithAddRef = TRUE) {
  312. if(bWithAddRef) {
  313. InternalAddRef();
  314. }
  315. return this;
  316. };*/
  317. //--------------------------------------------------------------------
  318. // Summary:
  319. //      Get one of stored objects by index.
  320. // Parameters:
  321. //      nIndex      : [in] Zero based index of the stored object.
  322. //      bWithAddRef : [in] If TRUE - InternalAddRef() is called before
  323. //                           returning pointer. It is TRUE by default.
  324. // Returns:
  325. //      Pointer to one of stored objects by index.
  326. // Remarks:
  327. //      This function gets pointer to one of stored objects by index
  328. //      and calls InternalAddRef() if specified.
  329. // See also:
  330. //      CArray::GetAt, IXTPInternalUnknown.
  331. //--------------------------------------------------------------------
  332. virtual _TObject* GetAt(int nIndex, BOOL bWithAddRef = TRUE)
  333. {
  334. TObjectPtr& rPtr = ElementAt(nIndex);
  335. _TObject* pObj = rPtr.GetInterface(bWithAddRef);
  336. return pObj;
  337. }
  338. //--------------------------------------------------------------------
  339. // Summary:
  340. //      Add object pointer to the array.
  341. // Parameters:
  342. //      pObj        : [in] Pointer to the storing object.
  343. //      bCallAddRef : [in] If TRUE - InternalAddRef() is called before
  344. //                           adding pointer. It is TRUE by default.
  345. // Returns:
  346. //      Added object index.
  347. // Remarks:
  348. //      This method add a new element to the collection
  349. //      and calls InternalAddRef() if specified.
  350. // See also:
  351. //      CArray::Add, IXTPInternalUnknown.
  352. //--------------------------------------------------------------------
  353. virtual int AddPtr(_TObject* pObj, BOOL bCallAddRef = FALSE)
  354. {
  355. TObjectPtr ptrObj(pObj, bCallAddRef);
  356. return (int)Add(ptrObj);
  357. }
  358. };
  359. //===========================================================================
  360. // Summary:
  361. //     This class represents a simple array of typed elements.
  362. //     It repeats CArray methods names and parameters as far as CArray behavior.
  363. // Remarks:
  364. //     This class derived from CCmdTarget. This allow to use it as base class
  365. //     for collection which has features for ActiveX support.
  366. // See Also: CArray, CCmdTarget.
  367. //===========================================================================
  368. template<class TYPE, class ARG_TYPE, class OLE_TYPE = long>
  369. class CXTPArrayT : public CXTPCmdTarget
  370. {
  371. public:
  372. //-----------------------------------------------------------------------
  373. // Summary:
  374. //     Default object constructor.
  375. //-----------------------------------------------------------------------
  376. CXTPArrayT();
  377. //-----------------------------------------------------------------------
  378. // Summary:
  379. //     Default object destructor.
  380. //-----------------------------------------------------------------------
  381. virtual ~CXTPArrayT();
  382. //-----------------------------------------------------------------------
  383. // Summary:
  384. //     This member function is used to obtain the number of elements
  385. //     in the collection.
  386. // Remarks:
  387. //     Call this method to retrieve the number of elements in the array.
  388. //     Because indexes are zero-based, the size is 1 greater than
  389. //     the largest index.
  390. // Returns:
  391. //     The number of items in the collection.
  392. //-----------------------------------------------------------------------
  393. virtual int GetSize() const;
  394. //-----------------------------------------------------------------------
  395. // Summary:
  396. //     This member function is used to change the array size.
  397. // Parameters:
  398. //     nNewSize - An int that contains the new array size.
  399. //     nGrowBy  - An int that contains a number of elements to grow
  400. //                internal data storage if need.
  401. // Remarks:
  402. //     Argument nNewSize contains the new array size (number of elements).
  403. //     Must be greater than or equal to 0.
  404. //-----------------------------------------------------------------------
  405. virtual void SetSize(int nNewSize, int nGrowBy = -1);
  406. //-----------------------------------------------------------------------
  407. // Summary:
  408. //     This member function returns an element at the specified
  409. //     numeric index.
  410. // Parameters:
  411. //     nIndex - An integer index that is greater than or equal to 0
  412. //              and less than the value returned by GetSIze.
  413. // Remarks:
  414. //     Returns the array element at the specified index.
  415. // Returns:
  416. //     The element currently at this index.
  417. //-----------------------------------------------------------------------
  418. virtual TYPE GetAt(int nIndex) const;
  419. //-----------------------------------------------------------------------
  420. // Summary:
  421. //     This member function is used to set a new element to the position
  422. //     specified in the nIndex parameter.
  423. // Parameters:
  424. //     nIndex      - An integer index that is greater than or equal
  425. //                   to 0 and less than the value returned by
  426. //                   GetCount.
  427. //     newElement  - A new value for the specified index.
  428. // Remarks:
  429. //     Use this method to set the specified element to the
  430. //     position specified in nIndex parameter.
  431. // See Also: GetAt, Add, InsertAt
  432. //-----------------------------------------------------------------------
  433. virtual void SetAt(int nIndex, ARG_TYPE newElement);
  434. //-----------------------------------------------------------------------
  435. // Summary:
  436. //     This member function returns a reference to element at the
  437. //     specified numeric index.
  438. // Parameters:
  439. //     nIndex - An integer index that is greater than or equal to 0
  440. //              and less than the value returned by GetSIze.
  441. // Returns:
  442. //     The array element reference at the specified index.
  443. //-----------------------------------------------------------------------
  444. virtual TYPE& ElementAt(int nIndex);
  445. //-----------------------------------------------------------------------
  446. // Summary:
  447. //     This member function is used to Direct Access to the element data.
  448. //     May return NULL.
  449. // Returns:
  450. //     The pointer to allocated array data or NULL.
  451. //-----------------------------------------------------------------------
  452. virtual const TYPE* GetData() const;
  453. virtual TYPE* GetData(); //<COMBINE GetData>
  454. //-----------------------------------------------------------------------
  455. // Summary:
  456. //     This member function is used to set a new element to the position
  457. //     specified in the nIndex parameter.
  458. //     Potentially growing the array.
  459. // Parameters:
  460. //     nIndex      - An integer index that is greater than or equal
  461. //                   to 0 and less than the value returned by
  462. //                   GetCount.
  463. //     newElement  - A new value for the specified index.
  464. // Remarks:
  465. //     Use this method to set the specified element to the
  466. //     position specified in nIndex parameter.
  467. // See Also: SetAt, Add, InsertAt
  468. //-----------------------------------------------------------------------
  469. virtual void SetAtGrow(int nIndex, ARG_TYPE newElement);
  470. //-----------------------------------------------------------------------
  471. // Summary:
  472. //     This member function adds a new element to the end of the array.
  473. // Parameters:
  474. //     newElement  - A new value for the specified index.
  475. //-----------------------------------------------------------------------
  476. virtual int Add(ARG_TYPE newElement);
  477. //-----------------------------------------------------------------------
  478. // Summary:
  479. //     This member function is used to add a new elements to the end
  480. //     of the array.
  481. // Parameters:
  482. //     src - A reference to an array of TYPE objects to add to this array.
  483. // Remarks:
  484. //     Use this method to add the elements from the specified
  485. //     array to the end of the collection.
  486. // See Also: GetAt, Add, InsertAt, SetAt
  487. //-----------------------------------------------------------------------
  488. virtual int Append(const CXTPArrayT& src);
  489. //-----------------------------------------------------------------------
  490. // Summary:
  491. //     This member function is used to copy elements from other array.
  492. // Parameters:
  493. //     src - A reference to an array of TYPE objects to add to this array.
  494. // Remarks:
  495. //     Use this method to copy elements from the specified
  496. //     array to this collection.
  497. // See Also: GetAt, Add, InsertAt, SetAt
  498. //-----------------------------------------------------------------------
  499. virtual void Copy(const CXTPArrayT& src);
  500. //-----------------------------------------------------------------------
  501. // Summary:
  502. //     This operator returns an element at the specified
  503. //     numeric index.
  504. // Parameters:
  505. //     nIndex - An integer index that is greater than or equal to 0
  506. //              and less than the value returned by GetSIze.
  507. // Remarks:
  508. //     Returns the array element at the specified index.
  509. // Returns:
  510. //     The element currently at this index.
  511. //-----------------------------------------------------------------------
  512. TYPE operator[](int nIndex) const;
  513. //-----------------------------------------------------------------------
  514. // Summary:
  515. //     This operator returns a reference to element at the
  516. //     specified numeric index.
  517. // Parameters:
  518. //     nIndex - An integer index that is greater than or equal to 0
  519. //              and less than the value returned by GetSIze.
  520. // Returns:
  521. //     The array element reference at the specified index.
  522. //-----------------------------------------------------------------------
  523. TYPE& operator[](int nIndex);
  524. //-----------------------------------------------------------------------
  525. // Summary:
  526. //     This member function is used to insert a new element at the
  527. //     position specified in the nIndex parameter.
  528. // Parameters:
  529. //     nIndex      - An integer index that is greater than or equal
  530. //                   to 0 and less than the value returned by
  531. //                   GetCount().
  532. //     newElement  - A new value for the specified index.
  533. //     nCount      - A number of elements to be inserted. By default is 1.
  534. //-----------------------------------------------------------------------
  535. virtual void InsertAt(int nIndex, ARG_TYPE newElement, int nCount = 1);
  536. //-----------------------------------------------------------------------
  537. // Summary:
  538. //     This member function removes an element at the specified index
  539. //     from the array.
  540. // Parameters:
  541. //     nIndex - An integer index that is greater than or equal to 0
  542. //              and less than the value returned by GetCount().
  543. //     nCount - The number of elements to remove.
  544. //-----------------------------------------------------------------------
  545. virtual void RemoveAt(int nIndex, int nCount = 1);
  546. //-----------------------------------------------------------------------
  547. // Summary:
  548. //     This member function is used to remove all of the elements from
  549. //     the array.
  550. // See Also: RemoveAt
  551. //-----------------------------------------------------------------------
  552. virtual void RemoveAll();
  553. //-----------------------------------------------------------------------
  554. // Summary:
  555. //     This member function is used to insert a new elements at the
  556. //     position specified in the nIndex parameter.
  557. // Parameters:
  558. //     nStartIndex - An integer index that is greater than or equal
  559. //                   to 0 and less than the value returned by
  560. //                   GetCount().
  561. //     pNewArray   - A pointer to the array which contains values to insert.
  562. //-----------------------------------------------------------------------
  563. virtual void InsertAt(int nStartIndex, CXTPArrayT* pNewArray);
  564. //-----------------------------------------------------------------------
  565. // Summary:
  566. //     Call this member function to find element in the collection.
  567. // Parameters:
  568. //     nElement - element to find.
  569. // Returns:
  570. //     Zero based index in the collection or -1 if element does not find.
  571. //-----------------------------------------------------------------------
  572. virtual int FindElement(ARG_TYPE nElement) const;
  573. //-----------------------------------------------------------------------
  574. // Summary:
  575. //     Call this member function to Add ID to collection only once.
  576. // Parameters:
  577. //     newElement - An element to add.
  578. // Remarks:
  579. //     If specified element already present in the collection - method do nothing.
  580. // See Also: CArray::Add
  581. //-----------------------------------------------------------------------
  582. virtual void AddIfNeed(ARG_TYPE newElement);
  583. //-----------------------------------------------------------------------
  584. // Summary:
  585. //     Call this member function to remove element from the collection.
  586. // Parameters:
  587. //     nElement - An element to remove.
  588. // Returns:
  589. //     TRUE if specified element find and removed, FALSE otherwise.
  590. //     This method removes all elements with the specified value.
  591. // See Also: CArray::RemoveAt, CArray::RemoveAll
  592. //-----------------------------------------------------------------------
  593. virtual BOOL RemoveElement(ARG_TYPE nElement);
  594. protected:
  595. CArray<TYPE, ARG_TYPE> m_arElements; // Elements storage.
  596. protected:
  597. // OLE collection implementation helpers for macros DECLARE_ENUM_VARIANT_EX(derived-class, long);
  598. //{{AFX_CODEJOCK_PRIVATE
  599. virtual long OleGetItemCount();
  600. virtual OLE_TYPE OleGetItem(long nIndex);
  601. virtual void OleSetItem(long nIndex, OLE_TYPE oleValue);
  602. virtual void OleAdd(OLE_TYPE otElement);
  603. virtual void OleRemove(long nIndex);
  604. virtual void OleRemoveAll();
  605. //}}AFX_CODEJOCK_PRIVATE
  606. };
  607. /////////////////////////////////////////////////////////////////////////////
  608. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  609. CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::CXTPArrayT()
  610. {
  611. }
  612. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  613. CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::~CXTPArrayT()
  614. {
  615. }
  616. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  617. AFX_INLINE int CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::GetSize() const
  618. {
  619. return (int)m_arElements.GetSize();
  620. }
  621. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  622. AFX_INLINE void CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::SetSize(int nNewSize, int nGrowBy)
  623. {
  624. m_arElements.SetSize(nNewSize, nGrowBy);
  625. }
  626. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  627. AFX_INLINE void CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::RemoveAll()
  628. {
  629. m_arElements.RemoveAll();
  630. }
  631. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  632. AFX_INLINE TYPE CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::GetAt(int nIndex) const
  633. {
  634. return m_arElements.GetAt(nIndex);
  635. }
  636. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  637. AFX_INLINE void CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::SetAt(int nIndex, ARG_TYPE newElement)
  638. {
  639. m_arElements.SetAt(nIndex, newElement);
  640. }
  641. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  642. AFX_INLINE TYPE& CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::ElementAt(int nIndex)
  643. {
  644. return m_arElements.ElementAt(nIndex);
  645. }
  646. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  647. AFX_INLINE const TYPE* CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::GetData() const
  648. {
  649. return m_arElements.GetData();
  650. }
  651. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  652. AFX_INLINE TYPE* CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::GetData()
  653. {
  654. return m_arElements.GetData();
  655. }
  656. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  657. AFX_INLINE void CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::SetAtGrow(int nIndex, ARG_TYPE newElement)
  658. {
  659. m_arElements.SetAtGrow(nIndex, newElement);
  660. }
  661. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  662. AFX_INLINE int CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::Add(ARG_TYPE newElement)
  663. {
  664. return (int)m_arElements.Add(newElement);
  665. }
  666. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  667. AFX_INLINE int CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::Append(const CXTPArrayT& src)
  668. {
  669. return (int)m_arElements.Append(src.m_arElements);
  670. }
  671. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  672. AFX_INLINE void CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::Copy(const CXTPArrayT& src)
  673. {
  674. m_arElements.Copy(src.m_arElements);
  675. }
  676. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  677. AFX_INLINE TYPE CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::operator[](int nIndex) const
  678. {
  679. return m_arElements[nIndex];
  680. }
  681. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  682. AFX_INLINE TYPE& CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::operator[](int nIndex)
  683. {
  684. return m_arElements[nIndex];
  685. }
  686. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  687. AFX_INLINE void CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::InsertAt(int nIndex, ARG_TYPE newElement, int nCount)
  688. {
  689. m_arElements.InsertAt(nIndex, newElement, nCount);
  690. }
  691. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  692. AFX_INLINE void CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::RemoveAt(int nIndex, int nCount)
  693. {
  694. m_arElements.RemoveAt(nIndex, nCount);
  695. }
  696. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  697. AFX_INLINE void CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::InsertAt(int nStartIndex, CXTPArrayT* pNewArray)
  698. {
  699. ASSERT(pNewArray);
  700. if (pNewArray)
  701. m_arElements.InsertAt(nStartIndex, &(pNewArray->m_arElements));
  702. }
  703. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  704. AFX_INLINE int CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::FindElement(ARG_TYPE nElement) const
  705. {
  706. int nCount = GetSize();
  707. for (int i = 0; i < nCount; i++)
  708. {
  709. if (GetAt(i) == nElement)
  710. return i;
  711. }
  712. return -1;
  713. }
  714. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  715. AFX_INLINE BOOL CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::RemoveElement(ARG_TYPE nElement)
  716. {
  717. BOOL bResult = FALSE;
  718. int nCount = GetSize();
  719. for (int i = nCount - 1; i >= 0; i--)
  720. {
  721. if (GetAt(i) == nElement)
  722. {
  723. RemoveAt(i);
  724. bResult = TRUE;
  725. }
  726. }
  727. return bResult;
  728. }
  729. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  730. AFX_INLINE void CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::AddIfNeed(ARG_TYPE newElement)
  731. {
  732. if (FindElement(newElement) < 0)
  733. {
  734. Add(newElement);
  735. }
  736. }
  737. //===========================================================================
  738. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  739. OLE_TYPE CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::OleGetItem(long nIndex)
  740. {
  741. if (nIndex < 0 || nIndex >= (long)GetSize())
  742. AfxThrowOleException(DISP_E_BADINDEX);
  743. return (OLE_TYPE)GetAt(nIndex);
  744. }
  745. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  746. void CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::OleSetItem(long nIndex, OLE_TYPE oleValue)
  747. {
  748. if (nIndex < 0 || nIndex >= (long)GetSize())
  749. AfxThrowOleException(DISP_E_BADINDEX);
  750. SetAt(nIndex, (ARG_TYPE)oleValue);
  751. }
  752. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  753. long CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::OleGetItemCount()
  754. {
  755. return (long)m_arElements.GetSize();
  756. }
  757. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  758. void CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::OleAdd(OLE_TYPE otElement)
  759. {
  760. Add((TYPE)otElement);
  761. }
  762. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  763. void CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::OleRemove(long nIndex)
  764. {
  765. if (nIndex < 0 || nIndex >= (long)GetSize())
  766. AfxThrowOleException(DISP_E_BADINDEX);
  767. RemoveAt(nIndex);
  768. }
  769. template<class TYPE, class ARG_TYPE, class OLE_TYPE>
  770. void CXTPArrayT<TYPE, ARG_TYPE, OLE_TYPE>::OleRemoveAll()
  771. {
  772. RemoveAll();
  773. }
  774. #endif // !defined(_XtpSmartPtrInternal_H__)