home *** CD-ROM | disk | FTP | other *** search
/ Power GUI Programming with VisualAge C++ / powergui.iso / trialva / ibmcppw / samples / visbuild / vbsample / iordrrec.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1996-02-16  |  16.3 KB  |  390 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) for C++                                               *
  11. *   (C) Copyright International Business Machines Corporation 1991, 1996       *
  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. #ifdef __OS2__
  61. #pragma handler(IOrderedRecord::IOrderedRecord())
  62. #pragma handler(IOrderedRecord::IOrderedRecord(const IString&))
  63. #pragma handler(IOrderedRecord::IOrderedRecord(const IOrderedRecord&))
  64. #pragma handler(IOrderedRecord::isOrdered())
  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 IOrderedRecord&))
  69. #pragma handler(IOrderedRecord::operator=(const IString&))
  70. #pragma handler(IOrderedRecord::operator==(const IOrderedRecord&))
  71. #pragma handler(IOrderedRecord::operator>(const IOrderedRecord&))
  72. #pragma handler(IOrderedRecord::operator>=(const IOrderedRecord&))
  73. #pragma handler(IOrderedRecord::~IOrderedRecord())
  74. #pragma handler(operator!=(const IOrderedRecord&,const IString&))
  75. #pragma handler(operator!=(const IString&,const IOrderedRecord&))
  76. #pragma handler(operator<(const IOrderedRecord&,const IString&))
  77. #pragma handler(operator<(const IString&,const IOrderedRecord&))
  78. #pragma handler(operator<=(const IOrderedRecord&,const IString&))
  79. #pragma handler(operator<=(const IString&,const IOrderedRecord&))
  80. #pragma handler(operator==(const IOrderedRecord&,const IString&))
  81. #pragma handler(operator==(const IString&,const IOrderedRecord&))
  82. #pragma handler(operator>(const IOrderedRecord&,const IString&))
  83. #pragma handler(operator>(const IString&,const IOrderedRecord&))
  84. #pragma handler(operator>=(const IOrderedRecord&,const IString&))
  85. #pragma handler(operator>=(const IString&,const IOrderedRecord&))
  86. #endif
  87.  
  88. /*------------------------------------------------------------------------------
  89. | Function Name: IOrderedRecord :: IOrderedRecord
  90. |
  91. | Implementation:
  92. |   Default initialization of the base class is okay.
  93. |-----------------------------------------------------------------------------*/
  94. IOrderedRecord :: IOrderedRecord()
  95. {
  96.   ;
  97. }
  98.  
  99. /*------------------------------------------------------------------------------
  100. | Function Name: IOrderedRecord :: IOrderedRecord
  101. |
  102. | Implementation:
  103. |   Initialize with the similar base class constructor.
  104. |-----------------------------------------------------------------------------*/
  105. IOrderedRecord :: IOrderedRecord ( const IString & recordData ) :
  106.                    IRecord( recordData )
  107. {
  108.   ;
  109. }
  110.  
  111. /*------------------------------------------------------------------------------
  112. | Function Name: IOrderedRecord :: IOrderedRecord
  113. |
  114. | Implementation:
  115. |   Initialize with the similar base class constructor.
  116. |-----------------------------------------------------------------------------*/
  117. IOrderedRecord :: IOrderedRecord ( const IOrderedRecord & aRecord ) :
  118.                    IRecord( aRecord )
  119. {
  120.   ;
  121. }
  122.  
  123. /*------------------------------------------------------------------------------
  124. | Function Name: IOrderedRecord :: ~IOrderedRecord
  125. |
  126. | Implementation:
  127. |   Default destruction is okay.
  128. |-----------------------------------------------------------------------------*/
  129. IOrderedRecord :: ~IOrderedRecord()
  130. {
  131.   ;
  132. }
  133.  
  134. /*------------------------------------------------------------------------------
  135. | Function Name: IOrderedRecord :: isOrdered
  136. |
  137. | Implementation:
  138. |   Of course, IOrderedRecord objects are ordered.
  139. ------------------------------------------------------------------------------*/
  140. IBoolean IOrderedRecord :: isOrdered ( ) const
  141. {
  142.   return( true );
  143. }
  144.  
  145. /*------------------------------------------------------------------------------
  146. | Function Name: IOrderedRecord :: operator ==
  147. |
  148. | Implementation:
  149. |   Invoke the similar IString operator.
  150. ------------------------------------------------------------------------------*/
  151. IBoolean IOrderedRecord :: operator == ( const IOrderedRecord & aRecord ) const
  152. {
  153.   return( sRecordData == aRecord.sRecordData );
  154. }
  155.  
  156. /*------------------------------------------------------------------------------
  157. | Function Name: operator ==
  158. |
  159. | Implementation:
  160. |   Invoke the similar IOrderedRecord virtual operator.
  161. ------------------------------------------------------------------------------*/
  162. IBoolean operator == ( const IOrderedRecord & record1,
  163.                        const IString & record2 )
  164. {
  165.   IOrderedRecord sRecord2( record2 );
  166.   return( record1 == sRecord2 );
  167. }
  168.  
  169. /*------------------------------------------------------------------------------
  170. | Function Name: operator ==
  171. |
  172. | Implementation:
  173. |   Invoke the similar IOrderedRecord virtual operator.
  174. ------------------------------------------------------------------------------*/
  175. IBoolean operator == ( const IString & record1,
  176.                        const IOrderedRecord & record2 )
  177. {
  178.   IOrderedRecord sRecord1( record1 );
  179.   return( sRecord1 == record2 );
  180. }
  181.  
  182. /*------------------------------------------------------------------------------
  183. | Function Name: IOrderedRecord :: operator !=
  184. |
  185. | Implementation:
  186. |   Invoke the similar IString operator.
  187. ------------------------------------------------------------------------------*/
  188. IBoolean IOrderedRecord :: operator != ( const IOrderedRecord & aRecord ) const
  189. {
  190.   return( sRecordData != aRecord.sRecordData );
  191. }
  192.  
  193. /*------------------------------------------------------------------------------
  194. | Function Name: operator !=
  195. |
  196. | Implementation:
  197. |   Invoke the similar IOrderedRecord virtual operator.
  198. ------------------------------------------------------------------------------*/
  199. IBoolean operator != ( const IOrderedRecord & record1,
  200.                        const IString & record2 )
  201. {
  202.   IOrderedRecord sRecord2( record2 );
  203.   return( record1 != sRecord2 );
  204. }
  205.  
  206. /*------------------------------------------------------------------------------
  207. | Function Name: operator !=
  208. |
  209. | Implementation:
  210. |   Invoke the similar IOrderedRecord virtual operator.
  211. ------------------------------------------------------------------------------*/
  212. IBoolean operator != ( const IString & record1,
  213.                        const IOrderedRecord & record2 )
  214. {
  215.   IOrderedRecord sRecord1( record1 );
  216.   return( sRecord1 != record2 );
  217. }
  218.  
  219. /*------------------------------------------------------------------------------
  220. | Function Name: IOrderedRecord :: operator <
  221. |
  222. | Implementation:
  223. |   Invoke the similar IString operator.
  224. ------------------------------------------------------------------------------*/
  225. IBoolean IOrderedRecord :: operator < ( const IOrderedRecord & aRecord ) const
  226. {
  227.   return( sRecordData < aRecord.sRecordData );
  228. }
  229.  
  230. /*------------------------------------------------------------------------------
  231. | Function Name: operator <
  232. |
  233. | Implementation:
  234. |   Invoke the similar IOrderedRecord virtual operator.
  235. ------------------------------------------------------------------------------*/
  236. IBoolean operator < ( const IOrderedRecord & record1,
  237.                       const IString & record2 )
  238. {
  239.   IOrderedRecord sRecord2( record2 );
  240.   return( record1 < sRecord2 );
  241. }
  242.  
  243. /*------------------------------------------------------------------------------
  244. | Function Name: operator <
  245. |
  246. | Implementation:
  247. |   Invoke the similar IOrderedRecord virtual operator.
  248. ------------------------------------------------------------------------------*/
  249. IBoolean operator < ( const IString & record1,
  250.                       const IOrderedRecord & record2 )
  251. {
  252.   IOrderedRecord sRecord1( record1 );
  253.   return( sRecord1 < record2 );
  254. }
  255.  
  256. /*------------------------------------------------------------------------------
  257. | Function Name: IOrderedRecord :: operator >
  258. |
  259. | Implementation:
  260. |   Invoke the similar IString operator.
  261. ------------------------------------------------------------------------------*/
  262. IBoolean IOrderedRecord :: operator > ( const IOrderedRecord & aRecord ) const
  263. {
  264.   return( sRecordData > aRecord.sRecordData );
  265. }
  266.  
  267. /*------------------------------------------------------------------------------
  268. | Function Name: operator >
  269. |
  270. | Implementation:
  271. |   Invoke the similar IOrderedRecord virtual operator.
  272. ------------------------------------------------------------------------------*/
  273. IBoolean operator > ( const IOrderedRecord & record1,
  274.                       const IString & record2 )
  275. {
  276.   IOrderedRecord sRecord2( record2 );
  277.   return( record1 > sRecord2 );
  278. }
  279.  
  280. /*------------------------------------------------------------------------------
  281. | Function Name: operator >
  282. |
  283. | Implementation:
  284. |   Invoke the similar IOrderedRecord virtual operator.
  285. ------------------------------------------------------------------------------*/
  286. IBoolean operator > ( const IString & record1,
  287.                       const IOrderedRecord & record2 )
  288. {
  289.   IOrderedRecord sRecord1( record1 );
  290.   return( sRecord1 > record2 );
  291. }
  292.  
  293. /*------------------------------------------------------------------------------
  294. | Function Name: IOrderedRecord :: operator <=
  295. |
  296. | Implementation:
  297. |   Invoke the similar IString operator.
  298. ------------------------------------------------------------------------------*/
  299. IBoolean IOrderedRecord :: operator <= ( const IOrderedRecord & aRecord ) const
  300. {
  301.   return( sRecordData <= aRecord.sRecordData );
  302. }
  303.  
  304. /*------------------------------------------------------------------------------
  305. | Function Name: operator <=
  306. |
  307. | Implementation:
  308. |   Invoke the similar IOrderedRecord virtual operator.
  309. ------------------------------------------------------------------------------*/
  310. IBoolean operator <= ( const IOrderedRecord & record1,
  311.                        const IString & record2 )
  312. {
  313.   IOrderedRecord sRecord2( record2 );
  314.   return( record1 <= sRecord2 );
  315. }
  316.  
  317. /*------------------------------------------------------------------------------
  318. | Function Name: operator <=
  319. |
  320. | Implementation:
  321. |   Invoke the similar IOrderedRecord virtual operator.
  322. ------------------------------------------------------------------------------*/
  323. IBoolean operator <= ( const IString & record1,
  324.                        const IOrderedRecord & record2 )
  325. {
  326.   IOrderedRecord sRecord1( record1 );
  327.   return( sRecord1 <= record2 );
  328. }
  329.  
  330. /*------------------------------------------------------------------------------
  331. | Function Name: IOrderedRecord :: operator >=
  332. |
  333. | Implementation:
  334. |   Invoke the similar IString operator.
  335. ------------------------------------------------------------------------------*/
  336. IBoolean IOrderedRecord :: operator >= ( const IOrderedRecord & aRecord ) const
  337. {
  338.   return( sRecordData >= aRecord.sRecordData );
  339. }
  340.  
  341. /*------------------------------------------------------------------------------
  342. | Function Name: operator >=
  343. |
  344. | Implementation:
  345. |   Invoke the similar IOrderedRecord virtual operator.
  346. ------------------------------------------------------------------------------*/
  347. IBoolean operator >= ( const IOrderedRecord & record1,
  348.                        const IString & record2 )
  349. {
  350.   IOrderedRecord sRecord2( record2 );
  351.   return( record1 >= sRecord2 );
  352. }
  353.  
  354. /*------------------------------------------------------------------------------
  355. | Function Name: operator >=
  356. |
  357. | Implementation:
  358. |   Invoke the similar IOrderedRecord virtual operator.
  359. ------------------------------------------------------------------------------*/
  360. IBoolean operator >= ( const IString & record1,
  361.                        const IOrderedRecord & record2 )
  362. {
  363.   IOrderedRecord sRecord1( record1 );
  364.   return( sRecord1 >= record2 );
  365. }
  366.  
  367. /*------------------------------------------------------------------------------
  368. | Function Name: IOrderedRecord :: operator =
  369. |
  370. | Implementation:
  371. |   Invoke the similar superclass assignment operator.
  372. ------------------------------------------------------------------------------*/
  373. IOrderedRecord & IOrderedRecord :: operator = ( const IOrderedRecord & aRecord )
  374. {
  375.   this->IRecord::operator=( aRecord );
  376.   return( *this );
  377. }
  378.  
  379. /*------------------------------------------------------------------------------
  380. | Function Name: IOrderedRecord :: operator =
  381. |
  382. | Implementation:
  383. |   Invoke the similar superclass assignment operator.
  384. ------------------------------------------------------------------------------*/
  385. IOrderedRecord & IOrderedRecord :: operator = ( const IString & aRecord )
  386. {
  387.   this->IRecord::operator=( aRecord );
  388.   return( *this );
  389. }
  390.