home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / VSCPPv8.zip / VACPP / IBMCPP / samples / VISBUILD / VBSAMPLE / IORDRREC.CPP < prev    next >
Text File  |  1995-05-10  |  17KB  |  388 lines
  1. /*******************************************************************************
  2. * FILE NAME: iordrrec.cpp                                                      *
  3. *                                                                              *
  4. * DESCRIPTION:                                                                 *
  5. *   Functions to implement the class(es):                                      *
  6. *     IOrderedRecord - Base class for classes that represent records           *
  7. *                      that have an ordering relationship.                     *
  8. *                                                                              *
  9. * COPYRIGHT:                                                                   *
  10. *   IBM(R) VisualAge(TM) C++ for OS/2(R), Version 3                            *
  11. *   (C) Copyright IBM Corporation 1991, 1995.                                  *
  12. *    - Licensed Material - Program-Property of IBM - All Rights Reserved.      *
  13. *   US Government Users Restricted Rights - Use, duplication, or disclosure    *
  14. *   restricted by GSA ADP Schedule Contract with IBM Corp.                     *
  15. *                                                                              *
  16. *   This program will not run in DOS mode.                                     *
  17. *                                                                              *
  18. * DISCLAIMER OF WARRANTIES:                                                    *
  19. *   The following [enclosed] code is sample code created by IBM                *
  20. *   Corporation.  This sample code is not part of any standard IBM product     *
  21. *   and is provided to you solely for the purpose of assisting you in the      *
  22. *   development of your applications.  The code is provided "AS IS",           *
  23. *   without warranty of any kind.  IBM shall not be liable for any damages     *
  24. *   arising out of your use of the sample code, even if they have been         *
  25. *   advised of the possibility of such damages.                                *
  26. *******************************************************************************/
  27. #include <iordrrec.hpp>
  28.  
  29. // Define the functions and static data members to be exported.
  30. // Ordinals 200 through 249 are reserved for use by IOrderedRecord.
  31. #pragma export(IOrderedRecord::IOrderedRecord(),, 200)
  32. #pragma export(IOrderedRecord::IOrderedRecord(const IString&),, 201)
  33. #pragma export(IOrderedRecord::IOrderedRecord(const IOrderedRecord&),, 202)
  34. #pragma export(IOrderedRecord::isOrdered() const,, 203)
  35. #pragma export(IOrderedRecord::operator!=(const IOrderedRecord&) const,, 204)
  36. #pragma export(IOrderedRecord::operator<(const IOrderedRecord&) const,, 205)
  37. #pragma export(IOrderedRecord::operator<=(const IOrderedRecord&) const,, 206)
  38. #pragma export(IOrderedRecord::operator=(const IOrderedRecord&),, 207)
  39. #pragma export(IOrderedRecord::operator=(const IString&),, 208)
  40. #pragma export(IOrderedRecord::operator==(const IOrderedRecord&) const,, 209)
  41. #pragma export(IOrderedRecord::operator>(const IOrderedRecord&) const,, 210)
  42. #pragma export(IOrderedRecord::operator>=(const IOrderedRecord&) const,, 211)
  43. #pragma export(IOrderedRecord::~IOrderedRecord(),, 212)
  44. #pragma export(operator!=(const IOrderedRecord&,const IString&),, 213)
  45. #pragma export(operator!=(const IString&,const IOrderedRecord&),, 214)
  46. #pragma export(operator<(const IOrderedRecord&,const IString&),, 215)
  47. #pragma export(operator<(const IString&,const IOrderedRecord&),, 216)
  48. #pragma export(operator<=(const IOrderedRecord&,const IString&),, 217)
  49. #pragma export(operator<=(const IString&,const IOrderedRecord&),, 218)
  50. #pragma export(operator==(const IOrderedRecord&,const IString&),, 219)
  51. #pragma export(operator==(const IString&,const IOrderedRecord&),, 220)
  52. #pragma export(operator>(const IOrderedRecord&,const IString&),, 221)
  53. #pragma export(operator>(const IString&,const IOrderedRecord&),, 222)
  54. #pragma export(operator>=(const IOrderedRecord&,const IString&),, 223)
  55. #pragma export(operator>=(const IString&,const IOrderedRecord&),, 224)
  56.  
  57. // It's possible for the caller of the external entry points to have a
  58. // different C library environment.  Make sure the exception handler for
  59. // our library environment is registered on entry and deregistered on exit.
  60. #pragma handler(IOrderedRecord::IOrderedRecord())
  61. #pragma handler(IOrderedRecord::IOrderedRecord(const IString&))
  62. #pragma handler(IOrderedRecord::IOrderedRecord(const IOrderedRecord&))
  63. #pragma handler(IOrderedRecord::isOrdered())
  64. #pragma handler(IOrderedRecord::operator!=(const IOrderedRecord&))
  65. #pragma handler(IOrderedRecord::operator<(const IOrderedRecord&))
  66. #pragma handler(IOrderedRecord::operator<=(const IOrderedRecord&))
  67. #pragma handler(IOrderedRecord::operator=(const IOrderedRecord&))
  68. #pragma handler(IOrderedRecord::operator=(const IString&))
  69. #pragma handler(IOrderedRecord::operator==(const IOrderedRecord&))
  70. #pragma handler(IOrderedRecord::operator>(const IOrderedRecord&))
  71. #pragma handler(IOrderedRecord::operator>=(const IOrderedRecord&))
  72. #pragma handler(IOrderedRecord::~IOrderedRecord())
  73. #pragma handler(operator!=(const IOrderedRecord&,const IString&))
  74. #pragma handler(operator!=(const IString&,const IOrderedRecord&))
  75. #pragma handler(operator<(const IOrderedRecord&,const IString&))
  76. #pragma handler(operator<(const IString&,const IOrderedRecord&))
  77. #pragma handler(operator<=(const IOrderedRecord&,const IString&))
  78. #pragma handler(operator<=(const IString&,const IOrderedRecord&))
  79. #pragma handler(operator==(const IOrderedRecord&,const IString&))
  80. #pragma handler(operator==(const IString&,const IOrderedRecord&))
  81. #pragma handler(operator>(const IOrderedRecord&,const IString&))
  82. #pragma handler(operator>(const IString&,const IOrderedRecord&))
  83. #pragma handler(operator>=(const IOrderedRecord&,const IString&))
  84. #pragma handler(operator>=(const IString&,const IOrderedRecord&))
  85.  
  86. /*------------------------------------------------------------------------------
  87. | Function Name: IOrderedRecord :: IOrderedRecord
  88. |
  89. | Implementation:
  90. |   Default initialization of the base class is okay.
  91. |-----------------------------------------------------------------------------*/
  92. IOrderedRecord :: IOrderedRecord()
  93. {
  94.   ;
  95. }
  96.  
  97. /*------------------------------------------------------------------------------
  98. | Function Name: IOrderedRecord :: IOrderedRecord
  99. |
  100. | Implementation:
  101. |   Initialize with the similar base class constructor.
  102. |-----------------------------------------------------------------------------*/
  103. IOrderedRecord :: IOrderedRecord ( const IString & recordData ) :
  104.                    IRecord( recordData )
  105. {
  106.   ;
  107. }
  108.  
  109. /*------------------------------------------------------------------------------
  110. | Function Name: IOrderedRecord :: IOrderedRecord
  111. |
  112. | Implementation:
  113. |   Initialize with the similar base class constructor.
  114. |-----------------------------------------------------------------------------*/
  115. IOrderedRecord :: IOrderedRecord ( const IOrderedRecord & aRecord ) :
  116.                    IRecord( aRecord )
  117. {
  118.   ;
  119. }
  120.  
  121. /*------------------------------------------------------------------------------
  122. | Function Name: IOrderedRecord :: ~IOrderedRecord
  123. |
  124. | Implementation:
  125. |   Default destruction is okay.
  126. |-----------------------------------------------------------------------------*/
  127. IOrderedRecord :: ~IOrderedRecord()
  128. {
  129.   ;
  130. }
  131.  
  132. /*------------------------------------------------------------------------------
  133. | Function Name: IOrderedRecord :: isOrdered
  134. |
  135. | Implementation:
  136. |   Of course, IOrderedRecord objects are ordered.
  137. ------------------------------------------------------------------------------*/
  138. IBoolean IOrderedRecord :: isOrdered ( ) const
  139. {
  140.   return( true );
  141. }
  142.  
  143. /*------------------------------------------------------------------------------
  144. | Function Name: IOrderedRecord :: operator ==
  145. |
  146. | Implementation:
  147. |   Invoke the similar IString operator.
  148. ------------------------------------------------------------------------------*/
  149. IBoolean IOrderedRecord :: operator == ( const IOrderedRecord & aRecord ) const
  150. {
  151.   return( sRecordData == aRecord.sRecordData );
  152. }
  153.  
  154. /*------------------------------------------------------------------------------
  155. | Function Name: operator ==
  156. |
  157. | Implementation:
  158. |   Invoke the similar IOrderedRecord virtual operator.
  159. ------------------------------------------------------------------------------*/
  160. IBoolean operator == ( const IOrderedRecord & record1,
  161.                        const IString & record2 )
  162. {
  163.   IOrderedRecord sRecord2( record2 );
  164.   return( record1 == sRecord2 );
  165. }
  166.  
  167. /*------------------------------------------------------------------------------
  168. | Function Name: operator ==
  169. |
  170. | Implementation:
  171. |   Invoke the similar IOrderedRecord virtual operator.
  172. ------------------------------------------------------------------------------*/
  173. IBoolean operator == ( const IString & record1,
  174.                        const IOrderedRecord & record2 )
  175. {
  176.   IOrderedRecord sRecord1( record1 );
  177.   return( sRecord1 == record2 );
  178. }
  179.  
  180. /*------------------------------------------------------------------------------
  181. | Function Name: IOrderedRecord :: operator !=
  182. |
  183. | Implementation:
  184. |   Invoke the similar IString operator.
  185. ------------------------------------------------------------------------------*/
  186. IBoolean IOrderedRecord :: operator != ( const IOrderedRecord & aRecord ) const
  187. {
  188.   return( sRecordData != aRecord.sRecordData );
  189. }
  190.  
  191. /*------------------------------------------------------------------------------
  192. | Function Name: operator !=
  193. |
  194. | Implementation:
  195. |   Invoke the similar IOrderedRecord virtual operator.
  196. ------------------------------------------------------------------------------*/
  197. IBoolean operator != ( const IOrderedRecord & record1,
  198.                        const IString & record2 )
  199. {
  200.   IOrderedRecord sRecord2( record2 );
  201.   return( record1 != sRecord2 );
  202. }
  203.  
  204. /*------------------------------------------------------------------------------
  205. | Function Name: operator !=
  206. |
  207. | Implementation:
  208. |   Invoke the similar IOrderedRecord virtual operator.
  209. ------------------------------------------------------------------------------*/
  210. IBoolean operator != ( const IString & record1,
  211.                        const IOrderedRecord & record2 )
  212. {
  213.   IOrderedRecord sRecord1( record1 );
  214.   return( sRecord1 != record2 );
  215. }
  216.  
  217. /*------------------------------------------------------------------------------
  218. | Function Name: IOrderedRecord :: operator <
  219. |
  220. | Implementation:
  221. |   Invoke the similar IString operator.
  222. ------------------------------------------------------------------------------*/
  223. IBoolean IOrderedRecord :: operator < ( const IOrderedRecord & aRecord ) const
  224. {
  225.   return( sRecordData < aRecord.sRecordData );
  226. }
  227.  
  228. /*------------------------------------------------------------------------------
  229. | Function Name: operator <
  230. |
  231. | Implementation:
  232. |   Invoke the similar IOrderedRecord virtual operator.
  233. ------------------------------------------------------------------------------*/
  234. IBoolean operator < ( const IOrderedRecord & record1,
  235.                       const IString & record2 )
  236. {
  237.   IOrderedRecord sRecord2( record2 );
  238.   return( record1 < sRecord2 );
  239. }
  240.  
  241. /*------------------------------------------------------------------------------
  242. | Function Name: operator <
  243. |
  244. | Implementation:
  245. |   Invoke the similar IOrderedRecord virtual operator.
  246. ------------------------------------------------------------------------------*/
  247. IBoolean operator < ( const IString & record1,
  248.                       const IOrderedRecord & record2 )
  249. {
  250.   IOrderedRecord sRecord1( record1 );
  251.   return( sRecord1 < record2 );
  252. }
  253.  
  254. /*------------------------------------------------------------------------------
  255. | Function Name: IOrderedRecord :: operator >
  256. |
  257. | Implementation:
  258. |   Invoke the similar IString operator.
  259. ------------------------------------------------------------------------------*/
  260. IBoolean IOrderedRecord :: operator > ( const IOrderedRecord & aRecord ) const
  261. {
  262.   return( sRecordData > aRecord.sRecordData );
  263. }
  264.  
  265. /*------------------------------------------------------------------------------
  266. | Function Name: operator >
  267. |
  268. | Implementation:
  269. |   Invoke the similar IOrderedRecord virtual operator.
  270. ------------------------------------------------------------------------------*/
  271. IBoolean operator > ( const IOrderedRecord & record1,
  272.                       const IString & record2 )
  273. {
  274.   IOrderedRecord sRecord2( record2 );
  275.   return( record1 > sRecord2 );
  276. }
  277.  
  278. /*------------------------------------------------------------------------------
  279. | Function Name: operator >
  280. |
  281. | Implementation:
  282. |   Invoke the similar IOrderedRecord virtual operator.
  283. ------------------------------------------------------------------------------*/
  284. IBoolean operator > ( const IString & record1,
  285.                       const IOrderedRecord & record2 )
  286. {
  287.   IOrderedRecord sRecord1( record1 );
  288.   return( sRecord1 > record2 );
  289. }
  290.  
  291. /*------------------------------------------------------------------------------
  292. | Function Name: IOrderedRecord :: operator <=
  293. |
  294. | Implementation:
  295. |   Invoke the similar IString operator.
  296. ------------------------------------------------------------------------------*/
  297. IBoolean IOrderedRecord :: operator <= ( const IOrderedRecord & aRecord ) const
  298. {
  299.   return( sRecordData <= aRecord.sRecordData );
  300. }
  301.  
  302. /*------------------------------------------------------------------------------
  303. | Function Name: operator <=
  304. |
  305. | Implementation:
  306. |   Invoke the similar IOrderedRecord virtual operator.
  307. ------------------------------------------------------------------------------*/
  308. IBoolean operator <= ( const IOrderedRecord & record1,
  309.                        const IString & record2 )
  310. {
  311.   IOrderedRecord sRecord2( record2 );
  312.   return( record1 <= sRecord2 );
  313. }
  314.  
  315. /*------------------------------------------------------------------------------
  316. | Function Name: operator <=
  317. |
  318. | Implementation:
  319. |   Invoke the similar IOrderedRecord virtual operator.
  320. ------------------------------------------------------------------------------*/
  321. IBoolean operator <= ( const IString & record1,
  322.                        const IOrderedRecord & record2 )
  323. {
  324.   IOrderedRecord sRecord1( record1 );
  325.   return( sRecord1 <= record2 );
  326. }
  327.  
  328. /*------------------------------------------------------------------------------
  329. | Function Name: IOrderedRecord :: operator >=
  330. |
  331. | Implementation:
  332. |   Invoke the similar IString operator.
  333. ------------------------------------------------------------------------------*/
  334. IBoolean IOrderedRecord :: operator >= ( const IOrderedRecord & aRecord ) const
  335. {
  336.   return( sRecordData >= aRecord.sRecordData );
  337. }
  338.  
  339. /*------------------------------------------------------------------------------
  340. | Function Name: operator >=
  341. |
  342. | Implementation:
  343. |   Invoke the similar IOrderedRecord virtual operator.
  344. ------------------------------------------------------------------------------*/
  345. IBoolean operator >= ( const IOrderedRecord & record1,
  346.                        const IString & record2 )
  347. {
  348.   IOrderedRecord sRecord2( record2 );
  349.   return( record1 >= sRecord2 );
  350. }
  351.  
  352. /*------------------------------------------------------------------------------
  353. | Function Name: operator >=
  354. |
  355. | Implementation:
  356. |   Invoke the similar IOrderedRecord virtual operator.
  357. ------------------------------------------------------------------------------*/
  358. IBoolean operator >= ( const IString & record1,
  359.                        const IOrderedRecord & record2 )
  360. {
  361.   IOrderedRecord sRecord1( record1 );
  362.   return( sRecord1 >= record2 );
  363. }
  364.  
  365. /*------------------------------------------------------------------------------
  366. | Function Name: IOrderedRecord :: operator =
  367. |
  368. | Implementation:
  369. |   Invoke the similar superclass assignment operator.
  370. ------------------------------------------------------------------------------*/
  371. IOrderedRecord & IOrderedRecord :: operator = ( const IOrderedRecord & aRecord )
  372. {
  373.   this->IRecord::operator=( aRecord );
  374.   return( *this );
  375. }
  376.  
  377. /*------------------------------------------------------------------------------
  378. | Function Name: IOrderedRecord :: operator =
  379. |
  380. | Implementation:
  381. |   Invoke the similar superclass assignment operator.
  382. ------------------------------------------------------------------------------*/
  383. IOrderedRecord & IOrderedRecord :: operator = ( const IString & aRecord )
  384. {
  385.   this->IRecord::operator=( aRecord );
  386.   return( *this );
  387. }
  388.