home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / opendc12.zip / od124os2.exe / od12osp1.exe / src / utils / BArray.cpp < prev    next >
C/C++ Source or Header  |  1997-04-02  |  9KB  |  309 lines
  1. //====START_GENERATED_PROLOG======================================
  2. //
  3. //
  4. //   COMPONENT_NAME: odutils
  5. //
  6. //   CLASSES: none
  7. //
  8. //   ORIGINS: 82,27
  9. //
  10. //
  11. //   (C) COPYRIGHT International Business Machines Corp. 1995,1996
  12. //   All Rights Reserved
  13. //   Licensed Materials - Property of IBM
  14. //   US Government Users Restricted Rights - Use, duplication or
  15. //   disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
  16. //       
  17. //   IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  18. //   ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  19. //   PURPOSE. IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  20. //   CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
  21. //   USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  22. //   OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE
  23. //   OR PERFORMANCE OF THIS SOFTWARE.
  24. //
  25. //====END_GENERATED_PROLOG========================================
  26. //
  27. // @(#) 1.7 com/src/utils/BArray.cpp, odutils, od96os2, odos29712d 8/19/96 11:47:22 [ 3/21/97 17:20:50 ]
  28. /*
  29.     File:        BArray.cpp
  30.  
  31.     Contains:    ByteArray implementation
  32.  
  33.     Owned by:    Vincent Lo
  34.  
  35.     Copyright:    ⌐ 1994 - 1995 by Apple Computer, Inc., all rights reserved.
  36.  
  37.     
  38. */
  39.  
  40. #define _OD_DONT_IMPORT_CPP_
  41.  
  42. #ifndef _ODTYPES_
  43. #include <ODTypes.h>
  44. #endif
  45.  
  46. #ifndef _BARRAY_
  47. #include <BArray.h>
  48. #endif
  49.  
  50. #ifndef _ODEXCEPT_
  51. #include <ODExcept.h>
  52. #endif
  53.  
  54. #ifndef SOM_Module_OpenDoc_Errors_defined
  55. #include <ErrorDef.xh>
  56. #endif
  57.  
  58. #ifdef _UNICODE_
  59.   ODShortArray  CreateShortArrayStruct(void* buffer, ODULong size);
  60.   ODShortArray  CreateEmptyShortArrayStruct(ODULong maximum);
  61.   ODShortArray  CopyShortArrayStruct(ODShortArray* fromSA);
  62.   void          DisposeShortArrayStruct(ODShortArray* byteArray);
  63. #endif
  64.  
  65. //------------------------------------------------------------------------------
  66. // CreateByteArray
  67. //------------------------------------------------------------------------------
  68.  
  69. WIN32_DLLEXPORT ODByteArray* CreateByteArray(void* buffer, ODULong size)
  70. {
  71.     ODByteArray*    ba = (ODByteArray*) SOMMalloc( sizeof(ODByteArray) );
  72.  
  73.     if (ba != kODNULL) {
  74.  
  75.         ba->_buffer = (octet*) SOMCalloc(size, sizeof(octet) );
  76.  
  77.         if (ba->_buffer) {
  78.             memcpy(ba->_buffer, buffer, size);
  79.             ba->_length = size;
  80.             ba->_maximum = size;
  81.         }
  82.         else
  83.             THROW(kODErrOutOfMemory);
  84.     }
  85.     else
  86.         THROW(kODErrOutOfMemory);
  87.     
  88.     return ba;
  89. }
  90.  
  91. //------------------------------------------------------------------------------
  92. // CreateByteArrayStruct
  93. //------------------------------------------------------------------------------
  94.  
  95. WIN32_DLLEXPORT ODByteArray CreateByteArrayStruct(void* buffer, ODULong size)
  96. {
  97.     ODByteArray    ba = CreateEmptyByteArrayStruct(size);
  98.  
  99.     if ( size > 0 )
  100.     {
  101.         memcpy(ba._buffer, buffer, size);
  102.         ba._length = size;
  103.     }
  104.     
  105.     return ba;
  106. }
  107.  
  108. //------------------------------------------------------------------------------
  109. // CreateEmptyByteArray
  110. //------------------------------------------------------------------------------
  111.  
  112. WIN32_DLLEXPORT ODByteArray* CreateEmptyByteArray(ODULong maximum)
  113. {
  114.     ODByteArray*    ba = (ODByteArray*) SOMMalloc( sizeof(ODByteArray) );
  115.     octet*        buffer = (octet*) SOMCalloc(maximum, sizeof(octet) );
  116.  
  117.  
  118.     if ((ba != kODNULL) && (buffer != kODNULL)) {
  119.         memset (buffer, '\0', maximum);
  120.         ba->_buffer = (octet *) buffer;
  121.         ba->_length = 0;
  122.         ba->_maximum = maximum;
  123.     }
  124.     else {
  125.         SOMFree ( ba );
  126.         SOMFree ( buffer );
  127.         THROW(kODErrOutOfMemory);
  128.     }
  129.     return ba;
  130. }
  131.  
  132. //------------------------------------------------------------------------------
  133. // CreateEmptyByteArrayStruct
  134. //------------------------------------------------------------------------------
  135.  
  136. WIN32_DLLEXPORT ODByteArray CreateEmptyByteArrayStruct(ODULong maximum)
  137. {
  138.     ODByteArray    ba;
  139.  
  140.     if ( maximum > 0 )
  141.     {
  142.         ba._buffer = (octet*) SOMCalloc(maximum, sizeof(octet) );
  143.         if ( ba._buffer == kODNULL )
  144.             THROW(kODErrOutOfMemory);
  145.  
  146.         memset (ba._buffer, '\0', maximum);
  147.     }
  148.     else
  149.         ba._buffer = kODNULL;
  150.  
  151.     ba._length = 0;
  152.     ba._maximum = maximum;
  153.  
  154.     return ba;
  155. }
  156.  
  157. //------------------------------------------------------------------------------
  158. // UseByteArray
  159. //------------------------------------------------------------------------------
  160.  
  161. WIN32_DLLEXPORT void UseByteArray(ODByteArray* ba, void* buffer, ODULong size)
  162. {
  163.     ba->_buffer = (octet *) buffer;
  164.     ba->_length = size;
  165.     ba->_maximum = size;
  166. }
  167.  
  168. //------------------------------------------------------------------------------
  169. // CopyByteArray
  170. //------------------------------------------------------------------------------
  171.  
  172. WIN32_DLLEXPORT ODByteArray* CopyByteArray(ODByteArray* fromBA)
  173. {
  174.     ODByteArray*    ba = (ODByteArray*) SOMMalloc( sizeof(ODByteArray) );
  175.     octet*        buffer = (octet*) SOMCalloc(fromBA->_maximum, sizeof(octet) );
  176.  
  177.  
  178.     if ((ba != kODNULL) && (buffer != kODNULL)) {
  179.         ba->_buffer = (octet*) buffer;
  180.         memcpy(ba->_buffer, fromBA->_buffer, fromBA->_length);
  181.         ba->_length = fromBA->_length;
  182.         ba->_maximum = fromBA->_maximum;
  183.     }
  184.     else {
  185.         SOMFree (ba);
  186.         SOMFree (buffer);
  187.         THROW(kODErrOutOfMemory);
  188.     }
  189.     return ba;    
  190. }
  191.  
  192. //------------------------------------------------------------------------------
  193. // CopyByteArrayStruct
  194. //------------------------------------------------------------------------------
  195.  
  196. WIN32_DLLEXPORT ODByteArray CopyByteArrayStruct(ODByteArray* fromBA)
  197. {
  198.     ODByteArray    ba = CreateEmptyByteArrayStruct(fromBA->_maximum);
  199.  
  200.     if ( fromBA->_length > 0 )
  201.     {
  202.         memcpy(ba._buffer, fromBA->_buffer, fromBA->_length);
  203.         ba._length = fromBA->_length;
  204.     }
  205.  
  206.     return ba;    
  207. }
  208.  
  209. //------------------------------------------------------------------------------
  210. // DisposeByteArray
  211. //------------------------------------------------------------------------------
  212.  
  213. WIN32_DLLEXPORT void DisposeByteArray(ODByteArray* array)
  214. {
  215.     if (array->_buffer != kODNULL)
  216.         SOMFree ( array->_buffer );
  217.     SOMFree ( array );
  218. }
  219.  
  220. //------------------------------------------------------------------------------
  221. // AreByteArraysEqual
  222. //------------------------------------------------------------------------------
  223.  
  224. WIN32_DLLEXPORT ODBoolean AreByteArraysEqual(ODByteArray* ba1, ODByteArray* ba2)
  225. {
  226.     return (((ba1->_length == ba2->_length) &&
  227.             !memcmp(ba1->_buffer, ba2->_buffer, ba1->_length)) ? kODTrue : kODFalse);
  228. }
  229. #ifdef _UNICODE_
  230.  
  231.  
  232. //------------------------------------------------------------------------------
  233. // CreateShortArrayStruct
  234. //------------------------------------------------------------------------------
  235.  
  236. ODShortArray  CreateShortArrayStruct(void* buffer, ODULong size)
  237. {
  238.         ODShortArray     ba = CreateEmptyShortArrayStruct(size);
  239.  
  240.         if ( size > 0 )
  241.         {
  242.                 memcpy(ba._buffer, buffer, size);
  243.                 ba._length = size;
  244.         }
  245.  
  246.         return ba;
  247. }
  248.  
  249. //------------------------------------------------------------------------------
  250. // CreateEmptyShortArrayStruct
  251. //------------------------------------------------------------------------------
  252.  
  253. ODShortArray  CreateEmptyShortArrayStruct(ODULong maximum)
  254. {
  255.         ODShortArray     ba;
  256.  
  257.         if ( maximum > 0 )
  258.         {
  259.                 ba._buffer = (unsigned short*) ODNewPtrClear(maximum);
  260.                 if ( ba._buffer == kODNULL )
  261.                         THROW(kODErrOutOfMemory);
  262.         }
  263.         else
  264.                 ba._buffer = kODNULL;
  265.  
  266.         ba._length = 0;
  267.         ba._maximum = maximum;
  268.  
  269.         return ba;
  270. }
  271.  
  272. //------------------------------------------------------------------------------
  273. // CopyShortArrayStruct
  274. //------------------------------------------------------------------------------
  275.  
  276. ODShortArray  CopyShortArrayStruct(ODShortArray* fromBA)
  277. {
  278.         ODShortArray     ba = CreateEmptyShortArrayStruct(fromBA->_maximum);
  279.  
  280.         if ( fromBA->_length > 0 )
  281.         {
  282.                 memcpy(ba._buffer, fromBA->_buffer, fromBA->_length);
  283.                 ba._length = fromBA->_length;
  284.         }
  285.  
  286.         return ba;
  287. }
  288.  
  289. //------------------------------------------------------------------------------
  290. // DisposeShortArrayStruct
  291. //------------------------------------------------------------------------------
  292. /*
  293.  *  [119548]
  294.  */
  295. void  DisposeShortArrayStruct(ODShortArray* byteArray)
  296. {
  297.  
  298.   if (byteArray->_buffer != kODNULL)
  299.   {
  300.     SOMFree (byteArray->_buffer);
  301.     byteArray->_buffer = kODNULL;
  302.   }
  303.   byteArray->_length = 0;
  304.   byteArray->_maximum = 0;
  305.  
  306. }
  307.  
  308. #endif
  309.