home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / VSCPPv8.zip / VACPP / IBMCPP / samples / VISBUILD / VBSAMPLE / IRECORD.CPP < prev    next >
Text File  |  1995-05-10  |  22KB  |  531 lines
  1. /*******************************************************************************
  2. * FILE NAME: irecord.cpp                                                       *
  3. *                                                                              *
  4. * DESCRIPTION:                                                                 *
  5. *   Functions to implement the class(es):                                      *
  6. *     IRecord - Base class for all record classes.                             *
  7. *                                                                              *
  8. * COPYRIGHT:                                                                   *
  9. *   IBM(R) VisualAge(TM) C++ for OS/2(R), Version 3                            *
  10. *   (C) Copyright IBM Corporation 1991, 1995.                                  *
  11. *    - Licensed Material - Program-Property of IBM - All Rights Reserved.      *
  12. *   US Government Users Restricted Rights - Use, duplication, or disclosure    *
  13. *   restricted by GSA ADP Schedule Contract with IBM Corp.                     *
  14. *                                                                              *
  15. *   This program will not run in DOS mode.                                     *
  16. *                                                                              *
  17. * DISCLAIMER OF WARRANTIES:                                                    *
  18. *   The following [enclosed] code is sample code created by IBM                *
  19. *   Corporation.  This sample code is not part of any standard IBM product     *
  20. *   and is provided to you solely for the purpose of assisting you in the      *
  21. *   development of your applications.  The code is provided "AS IS",           *
  22. *   without warranty of any kind.  IBM shall not be liable for any damages     *
  23. *   arising out of your use of the sample code, even if they have been         *
  24. *   advised of the possibility of such damages.                                *
  25. *******************************************************************************/
  26. #include <irecord.hpp>
  27.  
  28. #include <string.h>
  29.  
  30. // Define the functions and static data members to be exported.
  31. // Ordinals 350 through 399 are reserved for use by IRecord.
  32. #pragma export(IRecord::asString() const,, 350)
  33. #pragma export(IRecord::field(IString&,unsigned long,unsigned long,    \
  34.                    unsigned char) const,, 351)
  35. #pragma export(IRecord::field(char*,unsigned long,unsigned long,       \
  36.                    unsigned char) const,, 352)
  37. #pragma export(IRecord::field(char,unsigned long,unsigned char) const,, 353)
  38. #pragma export(IRecord::field(double,unsigned long,unsigned char) const,, 354)
  39. #pragma export(IRecord::field(float,unsigned long,unsigned char) const,, 355)
  40. #pragma export(IRecord::field(long double,unsigned long,unsigned char) const,, 356)
  41. #pragma export(IRecord::field(unsigned long,unsigned long,unsigned char) const,, 357)
  42. #pragma export(IRecord::field(unsigned short,unsigned long,unsigned char) const,, 358)
  43. #pragma export(IRecord::field(void*,unsigned long,unsigned long,       \
  44.                    unsigned char) const,, 359)
  45. #pragma export(IRecord::IRecord(),, 360)
  46. #pragma export(IRecord::IRecord(const IRecord&),, 361)
  47. #pragma export(IRecord::IRecord(const IString&),, 362)
  48. #pragma export(IRecord::isOrdered() const,, 363)
  49. #pragma export(IRecord::operator=(const IRecord&),, 364)
  50. #pragma export(IRecord::operator=(const IString&),, 365)
  51. #pragma export(IRecord::setField(const IString&,unsigned long,         \
  52.                    unsigned long, unsigned char),, 366)
  53. #pragma export(IRecord::setField(const char*,unsigned long,            \
  54.                    unsigned long,unsigned char),, 367)
  55. #pragma export(IRecord::setField(const char,unsigned long),, 368)
  56. #pragma export(IRecord::setField(const double,unsigned long),, 369)
  57. #pragma export(IRecord::setField(const float,unsigned long),, 370)
  58. #pragma export(IRecord::setField(const long double,unsigned long),, 371)
  59. #pragma export(IRecord::setField(const unsigned long,unsigned long),, 372)
  60. #pragma export(IRecord::setField(const unsigned short,unsigned long),, 373)
  61. #pragma export(IRecord::setField(const void*,unsigned long,unsigned long),, 374)
  62. #pragma export(IRecord::setSize(unsigned long),, 375)
  63. #pragma export(IRecord::size() const,, 376)
  64. #pragma export(IRecord::~IRecord(),, 377)
  65.  
  66. // It's possible for the caller of the external entry points to have a
  67. // different C library environment.  Make sure the exception handler for
  68. // our library environment is registered on entry and deregistered on exit.
  69. #pragma handler(IRecord::asString())
  70. #pragma handler(IRecord::field(IString&,unsigned long,unsigned long,   \
  71.                     unsigned char))
  72. #pragma handler(IRecord::field(char*,unsigned long,unsigned long,unsigned char))
  73. #pragma handler(IRecord::field(char,unsigned long,unsigned char))
  74. #pragma handler(IRecord::field(double,unsigned long,unsigned char))
  75. #pragma handler(IRecord::field(float,unsigned long,unsigned char))
  76. #pragma handler(IRecord::field(long double,unsigned long,unsigned char))
  77. #pragma handler(IRecord::field(unsigned long,unsigned long,unsigned char))
  78. #pragma handler(IRecord::field(unsigned short,unsigned long,unsigned char))
  79. #pragma handler(IRecord::field(void*,unsigned long,unsigned long,unsigned char))
  80. #pragma handler(IRecord::IRecord())
  81. #pragma handler(IRecord::IRecord(const IRecord&))
  82. #pragma handler(IRecord::IRecord(const IString&))
  83. #pragma handler(IRecord::isOrdered())
  84. #pragma handler(IRecord::operator=(const IRecord&))
  85. #pragma handler(IRecord::operator=(const IString&))
  86. #pragma handler(IRecord::setField(const IString&,unsigned long,        \
  87.                     unsigned long, unsigned char))
  88. #pragma handler(IRecord::setField(const char*,unsigned long,           \
  89.                     unsigned long,unsigned char))
  90. #pragma handler(IRecord::setField(const char,unsigned long))
  91. #pragma handler(IRecord::setField(const double,unsigned long))
  92. #pragma handler(IRecord::setField(const float,unsigned long))
  93. #pragma handler(IRecord::setField(const long double,unsigned long))
  94. #pragma handler(IRecord::setField(const unsigned long,unsigned long))
  95. #pragma handler(IRecord::setField(const unsigned short,unsigned long))
  96. #pragma handler(IRecord::setField(const void*,unsigned long,unsigned long))
  97. #pragma handler(IRecord::setSize(unsigned long))
  98. #pragma handler(IRecord::size())
  99. #pragma handler(IRecord::~IRecord())
  100.  
  101.  
  102. /*------------------------------------------------------------------------------
  103. | Function Name: IRecord :: IRecord
  104. |
  105. | Implementation:
  106. |   Default initialization of the record data IString is okay.
  107. |-----------------------------------------------------------------------------*/
  108. IRecord :: IRecord()
  109. {
  110.   ;
  111. }
  112.  
  113. /*------------------------------------------------------------------------------
  114. | Function Name: IRecord :: IRecord
  115. |
  116. | Implementation:
  117. |   Copy the passed in record data.
  118. |-----------------------------------------------------------------------------*/
  119. IRecord :: IRecord ( const IString & recordData ) :
  120.                    sRecordData( recordData )
  121. {
  122.   ;
  123. }
  124.  
  125. /*------------------------------------------------------------------------------
  126. | Function Name: IRecord :: IRecord
  127. |
  128. | Implementation:
  129. |   Copy the passed in record data.
  130. |-----------------------------------------------------------------------------*/
  131. IRecord :: IRecord ( const IRecord & aRecord ) :
  132.                    sRecordData( aRecord.sRecordData )
  133. {
  134.   ;
  135. }
  136.  
  137. /*------------------------------------------------------------------------------
  138. | Function Name: IRecord :: ~IRecord
  139. |
  140. | Implementation:
  141. |   The implementation IString is automatically deleted.
  142. |-----------------------------------------------------------------------------*/
  143. IRecord :: ~IRecord()
  144. {
  145.   ;
  146. }
  147.  
  148. /*------------------------------------------------------------------------------
  149. | Function Name: IRecord :: isOrdered
  150. |
  151. | Implementation:
  152. |   By default, IRecord objects are not ordered (see IOrderedRecord class).
  153. ------------------------------------------------------------------------------*/
  154. IBoolean IRecord :: isOrdered ( ) const
  155. {
  156.   return( false );
  157. }
  158.  
  159. /*------------------------------------------------------------------------------
  160. | Function Name: IRecord :: asString
  161. |
  162. | Implementation:
  163. |   Return a copy of the implementation string.
  164. ------------------------------------------------------------------------------*/
  165. IString IRecord :: asString ( ) const
  166. {
  167.   return( sRecordData );
  168. }
  169.  
  170. /*------------------------------------------------------------------------------
  171. | Function Name: IRecord :: operator =
  172. |
  173. | Implementation:
  174. |   Replace our data with the source IRecord data.
  175. ------------------------------------------------------------------------------*/
  176. IRecord & IRecord :: operator = ( const IRecord & aRecord )
  177. {
  178.   // Check for assignment to self.
  179.   if ( this != &aRecord )
  180.     sRecordData = aRecord.sRecordData;
  181.   return( *this );
  182. }
  183.  
  184. /*------------------------------------------------------------------------------
  185. | Function Name: IRecord :: operator =
  186. |
  187. | Implementation:
  188. |   Replace our data with the source IString data.
  189. ------------------------------------------------------------------------------*/
  190. IRecord & IRecord :: operator = ( const IString & aRecord )
  191. {
  192.   sRecordData = aRecord;
  193.   return( *this );
  194. }
  195.  
  196. /*------------------------------------------------------------------------------
  197. | Function Name: IRecord :: size
  198. |
  199. | Implementation:
  200. |   The IString size is the IRecord size.
  201. ------------------------------------------------------------------------------*/
  202. unsigned long IRecord :: size ( ) const
  203. {
  204.   return( sRecordData.size( ) );
  205. }
  206.  
  207. /*------------------------------------------------------------------------------
  208. | Function Name: IRecord :: setSize
  209. |
  210. | Implementation:
  211. |   Set the size of the IString to the requested size.
  212. ------------------------------------------------------------------------------*/
  213. unsigned long IRecord :: setSize ( unsigned long size )
  214. {
  215.   if ( sRecordData.size( ) > size )
  216.     sRecordData.remove( size + 1 );
  217.   else if ( sRecordData.size( ) < size )
  218.     sRecordData.insert( "", size, '\x00' );
  219.  
  220.   return( size );
  221. }
  222.  
  223. /*------------------------------------------------------------------------------
  224. | Function Name: IRecord :: field
  225. |
  226. | Implementation:
  227. |   Extract the field into the caller's buffer and return the buffer.
  228. ------------------------------------------------------------------------------*/
  229. void * IRecord :: field ( void * pBuffer,
  230.                           unsigned long recordOffset,
  231.                           unsigned long size,
  232.                           unsigned char padByte ) const
  233. {
  234.   IString theField = sRecordData.subString( recordOffset, size, padByte );
  235.   memcpy( pBuffer, (unsigned char *)theField, size );
  236.   return( pBuffer );
  237. }
  238.  
  239. /*------------------------------------------------------------------------------
  240. | Function Name: IRecord :: field
  241. |
  242. | Implementation:
  243. |   Extract the field into the caller's IString and return the IString.
  244. ------------------------------------------------------------------------------*/
  245. IString & IRecord :: field ( IString & buffer,
  246.                              unsigned long recordOffset,
  247.                              unsigned long size,
  248.                              unsigned char padByte ) const
  249. {
  250.   buffer = sRecordData.subString( recordOffset, size, padByte );
  251.   return( buffer );
  252. }
  253.  
  254. /*------------------------------------------------------------------------------
  255. | Function Name: IRecord :: field
  256. |
  257. | Implementation:
  258. |   Extract the field into the caller's null terminated character string
  259. |   and return the string.
  260. ------------------------------------------------------------------------------*/
  261. char * IRecord :: field ( char * pBuffer,
  262.                           unsigned long recordOffset,
  263.                           unsigned long size,
  264.                           unsigned char padByte ) const
  265. {
  266.   IString theField = sRecordData.subString( recordOffset, size, padByte );
  267.   memcpy( pBuffer, (unsigned char *)theField, size );
  268.   pBuffer[size] = '\x00';
  269.   return( pBuffer );
  270. }
  271.  
  272. /*------------------------------------------------------------------------------
  273. | Function Name: IRecord :: field
  274. |
  275. | Implementation:
  276. |   Extract a character and return it to the caller.
  277. ------------------------------------------------------------------------------*/
  278. char IRecord :: field ( char buffer,
  279.                         unsigned long recordOffset,
  280.                         unsigned char padByte ) const
  281. {
  282.   if ( recordOffset <= sRecordData.size() )
  283.     buffer = sRecordData[recordOffset];
  284.   else
  285.     buffer = padByte;
  286.  
  287.   return( buffer );
  288. }
  289.  
  290. /*------------------------------------------------------------------------------
  291. | Function Name: IRecord :: field
  292. |
  293. | Implementation:
  294. |   Extract a short integer and return it to the caller.
  295. ------------------------------------------------------------------------------*/
  296. unsigned short IRecord :: field ( unsigned short buffer,
  297.                                   unsigned long recordOffset,
  298.                                   unsigned char padByte ) const
  299. {
  300.   IString theField = sRecordData.subString( recordOffset,
  301.                                             sizeof(buffer),
  302.                                             padByte );
  303.   memcpy( &buffer, (unsigned char *)theField, sizeof(buffer) );
  304.   return( buffer );
  305. }
  306.  
  307. /*------------------------------------------------------------------------------
  308. | Function Name: IRecord :: field
  309. |
  310. | Implementation:
  311. |   Extract a long integer and return it to the caller.
  312. ------------------------------------------------------------------------------*/
  313. unsigned long IRecord :: field ( unsigned long buffer,
  314.                                  unsigned long recordOffset,
  315.                                  unsigned char padByte ) const
  316. {
  317.   IString theField = sRecordData.subString( recordOffset,
  318.                                             sizeof(buffer),
  319.                                             padByte );
  320.   memcpy( &buffer, (unsigned char *)theField, sizeof(buffer) );
  321.   return( buffer );
  322. }
  323.  
  324. /*------------------------------------------------------------------------------
  325. | Function Name: IRecord :: field
  326. |
  327. | Implementation:
  328. |   Extract a float and return it to the caller.
  329. ------------------------------------------------------------------------------*/
  330. float IRecord :: field ( float buffer,
  331.                          unsigned long recordOffset,
  332.                          unsigned char padByte ) const
  333. {
  334.   IString theField = sRecordData.subString( recordOffset,
  335.                                             sizeof(buffer),
  336.                                             padByte );
  337.   memcpy( &buffer, (unsigned char *)theField, sizeof(buffer) );
  338.   return( buffer );
  339. }
  340.  
  341. /*------------------------------------------------------------------------------
  342. | Function Name: IRecord :: field
  343. |
  344. | Implementation:
  345. |   Extract a double and return it to the caller.
  346. ------------------------------------------------------------------------------*/
  347. double IRecord :: field ( double buffer,
  348.                           unsigned long recordOffset,
  349.                           unsigned char padByte ) const
  350. {
  351.   IString theField = sRecordData.subString( recordOffset,
  352.                                             sizeof(buffer),
  353.                                             padByte );
  354.   memcpy( &buffer, (unsigned char *)theField, sizeof(buffer) );
  355.   return( buffer );
  356. }
  357.  
  358. /*------------------------------------------------------------------------------
  359. | Function Name: IRecord :: field
  360. |
  361. | Implementation:
  362. |   Extract a long double and return it to the caller.
  363. ------------------------------------------------------------------------------*/
  364. long double IRecord :: field ( long double buffer,
  365.                                unsigned long recordOffset,
  366.                                unsigned char padByte ) const
  367. {
  368.   IString theField = sRecordData.subString( recordOffset,
  369.                                             sizeof(buffer),
  370.                                             padByte );
  371.   memcpy( &buffer, (unsigned char *)theField, sizeof(buffer) );
  372.   return( buffer );
  373. }
  374.  
  375. /*------------------------------------------------------------------------------
  376. | Function Name: IRecord :: setField
  377. |
  378. | Implementation:
  379. |   Overlay the field with the caller's buffer and return the passed buffer.
  380. ------------------------------------------------------------------------------*/
  381. const void * IRecord :: setField ( const void * pData,
  382.                                    unsigned long recordOffset,
  383.                                    unsigned long size )
  384. {
  385.   IString theData( pData, size );
  386.   sRecordData.overlayWith( theData, recordOffset, '\x00' );
  387.   return( pData );
  388. }
  389.  
  390. /*------------------------------------------------------------------------------
  391. | Function Name: IRecord :: setField
  392. |
  393. | Implementation:
  394. |   Overlay the field with the caller's IString and return the passed IString.
  395. ------------------------------------------------------------------------------*/
  396. const IString & IRecord :: setField ( const IString & data,
  397.                                       unsigned long recordOffset,
  398.                                       unsigned long size,
  399.                                       unsigned char padByte )
  400. {
  401.   unsigned long copySize = size;
  402.   unsigned long padSize  = 0;
  403.   if ( data.size() < size )
  404.   {
  405.     copySize = data.size();
  406.     padSize  = size - data.size();
  407.   }
  408.   IString theData( (unsigned char *)data,
  409.                    copySize,
  410.                    NULL,
  411.                    padSize,
  412.                    padByte );
  413.   sRecordData.overlayWith( theData, recordOffset, '\x00' );
  414.   return( data );
  415. }
  416.  
  417. /*------------------------------------------------------------------------------
  418. | Function Name: IRecord :: setField
  419. |
  420. | Implementation:
  421. |   Overlay the field with the caller's null terminated character string and
  422. |   return the pointer to the passed character string.
  423. ------------------------------------------------------------------------------*/
  424. const char * IRecord :: setField ( const char * pData,
  425.                                    unsigned long recordOffset,
  426.                                    unsigned long size,
  427.                                    unsigned char padByte )
  428. {
  429.   unsigned long copySize = size;
  430.   unsigned long padSize  = 0;
  431.   if ( strlen( pData ) < size )
  432.   {
  433.     copySize = strlen( pData );
  434.     padSize  = size - strlen( pData );
  435.   }
  436.   IString theData( pData,
  437.                    copySize,
  438.                    NULL,
  439.                    padSize,
  440.                    padByte );
  441.   sRecordData.overlayWith( theData, recordOffset, '\x00' );
  442.   return( pData );
  443. }
  444.  
  445. /*------------------------------------------------------------------------------
  446. | Function Name: IRecord :: setField
  447. |
  448. | Implementation:
  449. |   Overlay the field with the caller's character and return passed character.
  450. ------------------------------------------------------------------------------*/
  451. const char IRecord :: setField ( const char data,
  452.                                  unsigned long recordOffset )
  453. {
  454.   IString theData( &data, sizeof(data) );
  455.   sRecordData.overlayWith( theData, recordOffset, '\x00' );
  456.   return( data );
  457. }
  458.  
  459. /*------------------------------------------------------------------------------
  460. | Function Name: IRecord :: setField
  461. |
  462. | Implementation:
  463. |   Overlay the field with the caller's short integer and return passed
  464. |   short integer.
  465. ------------------------------------------------------------------------------*/
  466. const unsigned short IRecord :: setField ( const unsigned short data,
  467.                                            unsigned long recordOffset )
  468. {
  469.   IString theData( &data, sizeof(data) );
  470.   sRecordData.overlayWith( theData, recordOffset, '\x00' );
  471.   return( data );
  472. }
  473.  
  474. /*------------------------------------------------------------------------------
  475. | Function Name: IRecord :: setField
  476. |
  477. | Implementation:
  478. |   Overlay the field with the caller's long integer and return passed
  479. |   long integer.
  480. ------------------------------------------------------------------------------*/
  481. const unsigned long IRecord :: setField ( const unsigned long data,
  482.                                           unsigned long recordOffset )
  483. {
  484.   IString theData( &data, sizeof(data) );
  485.   sRecordData.overlayWith( theData, recordOffset, '\x00' );
  486.   return( data );
  487. }
  488.  
  489. /*------------------------------------------------------------------------------
  490. | Function Name: IRecord :: setField
  491. |
  492. | Implementation:
  493. |   Overlay the field with the caller's float and return passed float.
  494. ------------------------------------------------------------------------------*/
  495. const float IRecord :: setField ( const float data,
  496.                                   unsigned long recordOffset )
  497. {
  498.   IString theData( &data, sizeof(data) );
  499.   sRecordData.overlayWith( theData, recordOffset, '\x00' );
  500.   return( data );
  501. }
  502.  
  503. /*------------------------------------------------------------------------------
  504. | Function Name: IRecord :: setField
  505. |
  506. | Implementation:
  507. |   Overlay the field with the caller's double and return passed double.
  508. ------------------------------------------------------------------------------*/
  509. const double IRecord :: setField ( const double data,
  510.                                    unsigned long recordOffset )
  511. {
  512.   IString theData( &data, sizeof(data) );
  513.   sRecordData.overlayWith( theData, recordOffset, '\x00' );
  514.   return( data );
  515. }
  516.  
  517. /*------------------------------------------------------------------------------
  518. | Function Name: IRecord :: setField
  519. |
  520. | Implementation:
  521. |   Overlay the field with the caller's long double and return passed
  522. |   long double.
  523. ------------------------------------------------------------------------------*/
  524. const long double IRecord :: setField ( const long double data,
  525.                                         unsigned long recordOffset )
  526. {
  527.   IString theData( &data, sizeof(data) );
  528.   sRecordData.overlayWith( theData, recordOffset, '\x00' );
  529.   return( data );
  530. }
  531.