home *** CD-ROM | disk | FTP | other *** search
/ Power GUI Programming with VisualAge C++ / powergui.iso / trialva / ibmcppw / include / iices.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-02-22  |  10.4 KB  |  387 lines
  1. /**********************************************************************
  2. *                                                                     *
  3. *  IBM(R) VisualAge(TM) for C++ for Windows(R), Version 3.5           *
  4. *                                                                     *
  5. *  PID: 5622-880                                                      *
  6. *  - Licensed Material - Program-Property of IBM                      *
  7. *  (C) Copyright IBM Corp. 1991, 1995 - All Right Reserved.           *
  8. *                                                                     *
  9. *  US Government Users Restricted Rights - Use, duplication or        *
  10. *  disclosure restricted by GSA ADP Schedule Contract with IBM Corp.  *
  11. *                                                                     *
  12. *  VisualAge, and IBM are trademarks or registered trademarks of      *
  13. *  International Business Machines Corporation.                       *
  14. *  Windows is a registered trademark of Microsoft Corporation.        *
  15. *                                                                     *
  16. **********************************************************************/
  17.  
  18. #include <iiexc.h>
  19.  
  20. #pragma info (nocls, nocnd, nocns, nocnv, noext, nognr, novft)
  21. #pragma pack (4)
  22.  
  23. // ---
  24. // ICEqualitySequenceImpl
  25. // ---
  26.  
  27. // public members
  28.  
  29. template <class CInherited>
  30. ICEqualitySequenceImpl <CInherited>::
  31. ICEqualitySequenceImpl (Ops& ops, INumber numberOfElements)
  32. : CInherited (ops, numberOfElements)
  33. {
  34. }
  35.  
  36. template <class CInherited>
  37. ICEqualitySequenceImpl <CInherited>::
  38. ICEqualitySequenceImpl
  39.   (Ops& ops, ICEqualitySequenceImpl <CInherited> const& collection)
  40. : CInherited (ops, collection)
  41. {
  42. }
  43.  
  44. template <class CInherited>
  45. IBoolean
  46. ICEqualitySequenceImpl <CInherited>::
  47. Add (void const* element, ICursorImpl& cursor)
  48. { ICHECK_IsFor      (ClassName (), "Add")
  49.  
  50.   IBoolean hasBeenAdded = CInherited::Add (element, cursor);
  51.   return hasBeenAdded;
  52. }
  53.  
  54. template <class CInherited>
  55. void
  56. ICEqualitySequenceImpl <CInherited>::
  57. AddAllFrom (IACollectionImpl const& collection)
  58. { ICHECK_Identical (ClassName (), "AddAllFrom")
  59.  
  60.   CInherited::AddAllFrom (collection);
  61. }
  62.  
  63. template <class CInherited>
  64. void
  65. ICEqualitySequenceImpl <CInherited>::
  66. AddAsFirst (void const* element, ICursorImpl& cursor)
  67. { ICHECK_IsFor (ClassName (), "AddAsFirst")
  68.  
  69.   CInherited::AddAsFirst (element, cursor);
  70. }
  71.  
  72. template <class CInherited>
  73. void
  74. ICEqualitySequenceImpl <CInherited>::
  75. AddAsLast (void const* element, ICursorImpl& cursor)
  76. { ICHECK_IsFor (ClassName (), "AddAsLast")
  77.  
  78.   CInherited::AddAsLast (element, cursor);
  79. }
  80.  
  81. template <class CInherited>
  82. void
  83. ICEqualitySequenceImpl <CInherited>::
  84. AddAsNext (void const* element, ICursorImpl& cursor)
  85. { ICHECK_IsFor   (ClassName (), "AddAsNext")
  86.   ICHECK_IsValid (ClassName (), "AddAsNext")
  87. #if defined (IALL_CHECKS)
  88.   ICHECK_Cursor  (ClassName (), "AddAsNext")
  89. #endif
  90.  
  91.   CInherited::AddAsNext (element, cursor);
  92. }
  93.  
  94. template <class CInherited>
  95. void
  96. ICEqualitySequenceImpl <CInherited>::
  97. AddAsPrevious (void const* element, ICursorImpl& cursor)
  98. { ICHECK_IsFor   (ClassName (), "AddAsPrevious")
  99.   ICHECK_IsValid (ClassName (), "AddAsPrevious")
  100. #if defined (IALL_CHECKS)
  101.   ICHECK_Cursor  (ClassName (), "AddAsPrevious")
  102. #endif
  103.  
  104.   CInherited::AddAsPrevious (element, cursor);
  105. }
  106.  
  107. template <class CInherited>
  108. void
  109. ICEqualitySequenceImpl <CInherited>::
  110. AddAtPosition (IPosition position,
  111.                void const* element,
  112.                ICursorImpl& cursor)
  113. { ICHECK_IsFor     (ClassName (), "AddAtPosition")
  114.   ICHECK_Position2 (ClassName (), "AddAtPosition")
  115.  
  116.   CInherited::AddAtPosition (position, element, cursor);
  117. }
  118.  
  119. template <class CInherited>
  120. void*
  121. ICEqualitySequenceImpl <CInherited>::
  122. Any () const
  123. { ICHECK_IsEmpty (ClassName (), "Any")
  124.  
  125.   return CInherited::Any ();
  126. }
  127.  
  128. template <class CInherited>
  129. void*
  130. ICEqualitySequenceImpl <CInherited>::
  131. ElementAt (ICursorImpl const& cursor) const
  132. { ICHECK_IsFor        (ClassName (), "ElementAt")
  133.   ICHECK_IsValid      (ClassName (), "ElementAt")
  134. #if defined (IALL_CHECKS)
  135.   ICHECK_Cursor       (ClassName (), "ElementAt")
  136. #endif
  137.  
  138.   return CInherited::ElementAt (cursor);
  139. }
  140.  
  141. template <class CInherited>
  142. void*
  143. ICEqualitySequenceImpl <CInherited>::
  144. ElementAtPosition (IPosition position) const
  145. { ICHECK_Position (ClassName (), "ElementAtPosition")
  146.  
  147.   return CInherited::ElementAtPosition (position);
  148. }
  149.  
  150. template <class CInherited>
  151. void*
  152. ICEqualitySequenceImpl <CInherited>::
  153. First () const
  154. { ICHECK_IsEmpty (ClassName (), "First")
  155.  
  156.   return CInherited::First ();
  157. }
  158.  
  159. template <class CInherited>
  160. IBoolean
  161. ICEqualitySequenceImpl <CInherited>::
  162. IsFirstAt (ICursorImpl const& cursor) const
  163. { ICHECK_IsFor        (ClassName (), "IsFirstAt")
  164.   ICHECK_IsValid      (ClassName (), "IsFirstAt")
  165. #if defined (IALL_CHECKS)
  166.   ICHECK_Cursor       (ClassName (), "IsFirstAt")
  167. #endif
  168.  
  169.   return CInherited::IsFirstAt (cursor);
  170. }
  171.  
  172. template <class CInherited>
  173. IBoolean
  174. ICEqualitySequenceImpl <CInherited>::
  175. IsLastAt (ICursorImpl const& cursor) const
  176. { ICHECK_IsFor        (ClassName (), "IsLastAt")
  177.   ICHECK_IsValid      (ClassName (), "IsLastAt")
  178. #if defined (IALL_CHECKS)
  179.   ICHECK_Cursor       (ClassName (), "IsLastAt")
  180. #endif
  181.  
  182.   return CInherited::IsLastAt (cursor);
  183. }
  184.  
  185. template <class CInherited>
  186. void*
  187. ICEqualitySequenceImpl <CInherited>::
  188. Last () const
  189. { ICHECK_IsEmpty (ClassName (), "Last")
  190.  
  191.   return CInherited::Last ();
  192. }
  193.  
  194. template <class CInherited>
  195. IBoolean
  196. ICEqualitySequenceImpl <CInherited>::
  197. Locate (void const* element, ICursorImpl& cursor) const
  198. { ICHECK_IsFor (ClassName (), "Locate")
  199.  
  200.   return CInherited::Locate (element, cursor);
  201. }
  202.  
  203. template <class CInherited>
  204. IBoolean
  205. ICEqualitySequenceImpl <CInherited>::
  206. LocateFirst (void const* element, ICursorImpl& cursor) const
  207. { ICHECK_IsFor (ClassName (), "LocateFirst")
  208.  
  209.   return CInherited::LocateFirst (element, cursor);
  210. }
  211.  
  212. template <class CInherited>
  213. IBoolean
  214. ICEqualitySequenceImpl <CInherited>::
  215. LocateLast (void const* element, ICursorImpl& cursor) const
  216. { ICHECK_IsFor (ClassName (), "LocateLast")
  217.  
  218.   return CInherited::LocateLast (element, cursor);
  219. }
  220.  
  221. template <class CInherited>
  222. IBoolean
  223. ICEqualitySequenceImpl <CInherited>::
  224. LocateNext (void const* element, ICursorImpl& cursor) const
  225. { ICHECK_IsFor   (ClassName (), "LocateNext")
  226.   ICHECK_IsValid (ClassName (), "LocateNext")
  227. #if defined (IALL_CHECKS)
  228.   ICHECK_Cursor  (ClassName (), "LocateNext")
  229. #endif
  230.  
  231.   return CInherited::LocateNext (element, cursor);
  232. }
  233.  
  234. template <class CInherited>
  235. IBoolean
  236. ICEqualitySequenceImpl <CInherited>::
  237. LocateOrAdd (void const* element, ICursorImpl& cursor)
  238. { ICHECK_IsFor (ClassName (), "LocateOrAdd")
  239.  
  240.   return CInherited::LocateOrAdd (element, cursor);
  241. }
  242.  
  243. template <class CInherited>
  244. IBoolean
  245. ICEqualitySequenceImpl <CInherited>::
  246. LocatePrevious (void const* element, ICursorImpl& cursor) const
  247. { ICHECK_IsFor   (ClassName (), "LocatePrevious")
  248.   ICHECK_IsValid (ClassName (), "LocatePrevious")
  249. #if defined (IALL_CHECKS)
  250.   ICHECK_Cursor  (ClassName (), "LocatePrevious")
  251. #endif
  252.  
  253.   return CInherited::LocatePrevious (element, cursor);
  254. }
  255.  
  256. template <class CInherited>
  257. IPosition
  258. ICEqualitySequenceImpl <CInherited>::
  259. PositionAt (ICursorImpl const& cursor) const
  260. { ICHECK_IsFor        (ClassName (), "PositionAt")
  261.   ICHECK_IsValid      (ClassName (), "PositionAt")
  262. #if defined (IALL_CHECKS)
  263.   ICHECK_Cursor       (ClassName (), "PositionAt")
  264. #endif
  265.  
  266.   return CInherited::PositionAt (cursor);
  267. }
  268.  
  269. template <class CInherited>
  270. void
  271. ICEqualitySequenceImpl <CInherited>::
  272. RemoveAt (ICursorImpl& cursor)
  273. { ICHECK_IsFor        (ClassName (), "RemoveAt")
  274.   ICHECK_IsValid      (ClassName (), "RemoveAt")
  275. #if defined (IALL_CHECKS)
  276.   ICHECK_Cursor       (ClassName (), "RemoveAt")
  277. #endif
  278.  
  279.   CInherited::RemoveAt (cursor);
  280. }
  281.  
  282. template <class CInherited>
  283. void
  284. ICEqualitySequenceImpl <CInherited>::
  285. RemoveAtPosition (IPosition position)
  286. { ICHECK_Position (ClassName (), "RemoveAtPosition")
  287.  
  288.   CInherited::RemoveAtPosition (position);
  289. }
  290.  
  291. template <class CInherited>
  292. void
  293. ICEqualitySequenceImpl <CInherited>::
  294. RemoveFirst ()
  295. { ICHECK_IsEmpty (ClassName (), "RemoveFirst")
  296.  
  297.   CInherited::RemoveFirst ();
  298. }
  299.  
  300. template <class CInherited>
  301. void
  302. ICEqualitySequenceImpl <CInherited>::
  303. RemoveLast ()
  304. { ICHECK_IsEmpty (ClassName (), "RemoveLast")
  305.  
  306.   CInherited::RemoveLast ();
  307. }
  308.  
  309. template <class CInherited>
  310. void
  311. ICEqualitySequenceImpl <CInherited>::
  312. ReplaceAt (ICursorImpl const& cursor, void const* element)
  313. { ICHECK_IsFor        (ClassName (), "ReplaceAt")
  314.   ICHECK_IsValid      (ClassName (), "ReplaceAt")
  315. #if defined (IALL_CHECKS)
  316.   ICHECK_Cursor       (ClassName (), "ReplaceAt")
  317. #endif
  318.  
  319.   CInherited::ReplaceAt (cursor, element);
  320. }
  321.  
  322. template <class CInherited>
  323. void
  324. ICEqualitySequenceImpl <CInherited>::
  325. ReplaceAtPosition (IPosition position, void const* element)
  326. { ICHECK_Position    (ClassName (), "ReplaceAtPosition")
  327.  
  328.   CInherited::ReplaceAtPosition (position, element);
  329. }
  330.  
  331. template <class CInherited>
  332. IBoolean
  333. ICEqualitySequenceImpl <CInherited>::
  334. SetToFirst (ICursorImpl& cursor) const
  335. { ICHECK_IsFor (ClassName (), "SetToFirst")
  336.  
  337.   return CInherited::SetToFirst (cursor);
  338. }
  339.  
  340. template <class CInherited>
  341. IBoolean
  342. ICEqualitySequenceImpl <CInherited>::
  343. SetToLast (ICursorImpl& cursor) const
  344. { ICHECK_IsFor (ClassName (), "SetToLast")
  345.  
  346.   return CInherited::SetToLast (cursor);
  347. }
  348.  
  349. template <class CInherited>
  350. IBoolean
  351. ICEqualitySequenceImpl <CInherited>::
  352. SetToNext (ICursorImpl& cursor) const
  353. { ICHECK_IsFor   (ClassName (), "SetToNext")
  354.   ICHECK_IsValid (ClassName (), "SetToNext")
  355. #if defined (IALL_CHECKS)
  356.   ICHECK_Cursor  (ClassName (), "SetToNext")
  357. #endif
  358.  
  359.   return CInherited::SetToNext (cursor);
  360. }
  361.  
  362. template <class CInherited>
  363. void
  364. ICEqualitySequenceImpl <CInherited>::
  365. SetToPosition (IPosition position, ICursorImpl& cursor) const
  366. { ICHECK_IsFor     (ClassName (), "SetToPosition")
  367.   ICHECK_Position  (ClassName (), "SetToPosition")
  368.  
  369.   CInherited::SetToPosition (position, cursor);
  370. }
  371.  
  372. template <class CInherited>
  373. IBoolean
  374. ICEqualitySequenceImpl <CInherited>::
  375. SetToPrevious (ICursorImpl& cursor) const
  376. { ICHECK_IsFor   (ClassName (), "SetToPrevious")
  377.   ICHECK_IsValid (ClassName (), "SetToPrevious")
  378. #if defined (IALL_CHECKS)
  379.   ICHECK_Cursor  (ClassName (), "SetToPrevious")
  380. #endif
  381.  
  382.   return CInherited::SetToPrevious (cursor);
  383. }
  384.  
  385. #pragma info (restore)
  386. #pragma pack ()
  387.