home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 22 gnu / 22-gnu.zip / db02_src.zip / mystring.h < prev    next >
C/C++ Source or Header  |  1994-02-22  |  8KB  |  351 lines
  1. /**************************************************************************
  2.  * Source Id :
  3.  *
  4.  * $Id: mystring.h,v 1.23 1993/11/05 12:45:05 kevinl Exp $
  5.  *-------------------------------------------------------------------------
  6.  * Project Notes :
  7.  *
  8.  *  Diamond Base
  9.  *  ============
  10.  *    A solid database implementation, spurred on by the continuing
  11.  *  Metal (Lead) Base saga.
  12.  *
  13.  *  Project Team :
  14.  *      A. Davison
  15.  *      K. Lentin
  16.  *      D. Platt
  17.  *
  18.  *    Project Commenced : 05-02-1993
  19.  *
  20.  *-------------------------------------------------------------------------
  21.  *  Module Notes :
  22.  *
  23.  *  mystring.h:
  24.  *  A the variable length string class for variable length records
  25.  *
  26.  *  Original Author : Kev
  27.  *
  28.  *-------------------------------------------------------------------------
  29.  * Revision History:
  30.  *
  31.  * $Log: mystring.h,v $
  32.  * Revision 1.23  1993/11/05  12:45:05    kevinl
  33.  * Fixed problems that CC picked up (and some multi bugs)
  34.  *
  35.  * Revision 1.22  1993/10/28  13:31:20    davison
  36.  * Changed clear() method to clr().
  37.  *
  38.  * Revision 1.21  1993/10/24  15:36:12    kevinl
  39.  * A spelling error and a dbString copy constructor
  40.  *
  41.  * Revision 1.20  1993/10/24  11:43:46    davison
  42.  * Fixed up operator +=(char) and =operator =(char).
  43.  * They now ensure that dummyc[1] = 0.
  44.  *
  45.  * Revision 1.19  1993/10/24  10:09:38    kevinl
  46.  * Removed a const
  47.  *
  48.  * Revision 1.18  1993/10/24  09:14:48    kevinl
  49.  * dummyc is now a char[2] so we can remove the aggregate initialiser
  50.  * from the char operators
  51.  *
  52.  * Revision 1.17  1993/10/19  11:59:05    kevinl
  53.  * copying (char*)0 or a totally empty dbData/dbString now truncates
  54.  *
  55.  * Revision 1.16  1993/10/18  09:07:23    davison
  56.  * Killed unsigned int manipulations.
  57.  * Added addSize & subSize.
  58.  * Added char concatination method.
  59.  *
  60.  * Revision 1.15  1993/10/18  05:55:51    davison
  61.  * Added a string comparison operator to dbString. Compiled ok. Hope it
  62.  * works :-)
  63.  *
  64.  * Revision 1.14  1993/10/05  07:34:31    kevinl
  65.  * Now handles dbData AND dbString properly
  66.  *
  67.  * Revision 1.13  1993/09/26  08:34:32    kevinl
  68.  * Fixed ambiguous constructors
  69.  *
  70.  * Revision 1.12  1993/08/29  12:56:27    kevinl
  71.  * Fixed problems of assigning relations to each other.
  72.  *
  73.  * Revision 1.11  1993/07/20  12:59:30    kevinl
  74.  * Some unisgned int vs long problems
  75.  *
  76.  * Revision 1.10  1993/07/19  11:57:58    kevinl
  77.  * Added some dummy cahrs to remove Borland warnings re temporaries
  78.  * Added some {} to remove Borland's confusion about multiple if/elses
  79.  *
  80.  * Revision 1.9  1993/07/13  00:18:08  kevinl
  81.  * We weren't setting size in cat/cpy johnb@kea.grace.cri.nz (John Burnell)
  82.  *
  83.  * Revision 1.8  1993/07/11  10:49:21  kevinl
  84.  * dbString version
  85.  *
  86.  * Revision 1.7  1993/07/11  09:42:05  kevinl
  87.  * Changed String to dbString
  88.  *
  89.  * Revision 1.6  1993/07/11  08:20:17  kevinl
  90.  * Fixed [] operator
  91.  * Added CHUNKSIZE
  92.  *
  93.  * Revision 1.5  1993/07/09  06:26:52  kevinl
  94.  * Made some operators that take String
  95.  *
  96.  * Revision 1.4  1993/07/09  03:57:55  kevinl
  97.  * Removed realloc of null pointers.
  98.  *
  99.  * Revision 1.3  1993/06/20  23:29:05  kevinl
  100.  * Added -=
  101.  *
  102.  * Revision 1.2  1993/06/20  13:38:27  kevinl
  103.  * Fixed multiple mallocs
  104.  * longs now unsigned int, cat/cpy return the string
  105.  * added fill, =,+= unsigned int and moved += operator in
  106.  *
  107.  * Revision 1.1  1993/06/18  12:31:14  kevinl
  108.  * Initial revision
  109.  *
  110.  **************************************************************************/
  111.  
  112. #ifndef __MYSTRING_H
  113. #define __MYSTRING_H
  114.  
  115. #if !defined(MALLOC_H_MISSING) && !defined(MALLOC_H_INCLUDED)
  116. extern "C" {
  117. #include <malloc.h>
  118. }
  119. #define MALLOC_H_INCLUDED
  120. #endif
  121. #ifdef __EMX__
  122. #include <strstrea.h>
  123. #else
  124. #include <strstream.h>
  125. #endif
  126. #include <string.h>
  127. #include <defs.h>
  128.  
  129. const CHUNKSIZE = 256;
  130.  
  131. class dbData
  132. {
  133.     char dummyc[2];
  134.     unsigned int isstr; // Extra space needed on end of data
  135.     unsigned int size;  // How much memory do we need for the char*;
  136. public:
  137.     char *data;  // The data being played with
  138.  
  139.     char* verStr(void) { return "$Id"; }
  140.     dbData(unsigned int e = 0) : isstr(e) { data=0; size=0; }
  141.     dbData(dbData& D) : isstr(D.isstr) { createDbData(D); }
  142.     dbData(dbData& D, unsigned int e) : isstr(e) { createDbData(D); }
  143.     void createDbData(dbData& D)
  144.     {
  145.         dummyc[1] = 0;
  146.         if (D.data) {
  147.             size=D.len()+isstr;
  148.             data = new char[size];
  149.             bcopy(D.data, data, size);
  150.         } else {
  151.             size=0;
  152.             data=0;
  153.         }
  154.     }
  155.     dbData(char* s, unsigned int e = 0) : isstr(e)
  156.     {
  157.         dummyc[1] = 0;
  158.         if (s) {
  159.             data = strdup(s);
  160.             size = strlen(s)+1;
  161.         } else {
  162.             size=0;
  163.             data=0;
  164.         }
  165.     }
  166.     dbData(void* s, unsigned int len, unsigned int e = 0) : isstr(e)
  167.     {
  168.         dummyc[1] = 0;
  169.         if (s) {
  170.             data = new char[len];
  171.             bcopy((char*)s, data, len);
  172.             size = len;
  173.         } else {
  174.             size=0;
  175.             data=0;
  176.         }
  177.     }
  178.     ~dbData(void) { if (data) free(data); data=0; size=0; }
  179.     unsigned int len(void) { return (isstr)?(data?strlen(data):0):size; }
  180.     unsigned int setSize(unsigned int newLen)
  181.     {
  182.         if (isstr && newLen < size) {
  183.             // Nothing
  184.         } else {
  185.             if (data) {
  186.                 data = (char*)realloc(data, newLen);
  187.             } else {
  188.                 data = new char[newLen];
  189.                 if (isstr) *data = 0;
  190.             }
  191.             size = newLen;
  192.         }
  193.         return size;
  194.     }
  195.     unsigned int getSize(void)
  196.     {
  197.         return size;
  198.     }
  199.     char* cat(char* s)
  200.     {
  201.         if (s) {
  202.             unsigned int slen = strlen(s);
  203.             unsigned int newsize = len()+slen+1; // always 1 'cos adding a string
  204.             unsigned int oldsize = len();
  205.             setSize(newsize);
  206.             bcopy(s, data+oldsize, slen+1);
  207.         }
  208.         return data;
  209.     }
  210.     char* cat(dbData& d)
  211.     {
  212.         if (d.data) {
  213.             unsigned int newsize = len()+d.len()+isstr;
  214.             unsigned int oldsize = len();
  215.             setSize(newsize);
  216.             bcopy(d.data, data+oldsize, d.len()+isstr);
  217.         }
  218.         return data;
  219.     }
  220.     char* cpy(char* s)
  221.     {
  222.         if (s) {
  223.             unsigned int slen = strlen(s);
  224.             setSize(slen+1);
  225.             bcopy(s, data, slen+1);
  226.         } else {
  227.             setSize(isstr);
  228.             if (isstr)
  229.                 *data = 0;
  230.         }
  231.         return data;
  232.     }
  233.     char* cpy(dbData& d)
  234.     {
  235.         if (d.data) {
  236.             setSize(d.len()+isstr);
  237.             bcopy(d.data, data, d.len()+isstr);
  238.         } else {
  239.             setSize(isstr);
  240.             if (isstr)
  241.                 *data = 0;
  242.         }
  243.         return data;
  244.     }
  245.     void fill(char c, unsigned int count = 0);
  246.     void clr(void) {
  247.         if (isstr) {
  248.             if (data) {
  249.                 data[0] = 0;
  250.             }
  251.         } else
  252.             dispose();
  253.     }
  254.     void dispose(void) { if (data) free(data); data=0; size=0; }
  255.     operator char*() { return data; }
  256.     operator void*() { return (void*)data; }
  257.     bool empty(void) { return (bool)(data != 0); }
  258.     friend dbData operator + (dbData& S, char* s);
  259.     friend dbData operator + (dbData& S, dbData& s);
  260.     friend ostream& operator << (ostream& o, dbData& s);
  261.     friend istream& operator >> (istream& i, dbData& s);
  262.     char& operator [] (unsigned int i) { return (data && i < size)?data[i]:dummyc[0]; }
  263.     dbData& operator = (char* s)
  264.     {
  265.         cpy(s);
  266.         return *this;
  267.     }
  268.     dbData& operator = (dbData& d)
  269.     {
  270.         cpy(d);
  271.         return *this;
  272.     }
  273.     dbData& operator = (char c)
  274.     {
  275.         dummyc[0] = c;
  276.         dummyc[1] = 0;
  277.         cpy(dummyc);
  278.         return *this;
  279.     }
  280.     dbData& operator += (char* s)
  281.     {
  282.         cat(s);
  283.         return *this;
  284.     }
  285.     dbData& operator += (dbData& d)
  286.     {
  287.         cat(d);
  288.         return *this;
  289.     }
  290.     dbData& operator += (char c)
  291.     {
  292.         dummyc[0] = c;
  293.         dummyc[1] = 0;
  294.         cat(dummyc);
  295.         return *this;
  296.     }
  297. #if 0
  298.     unsigned int operator = (unsigned int s)
  299.     {
  300.         unsigned int sz = setSize(s);
  301.         if (isstr && s)
  302.             data[s-1] = 0;
  303.         return sz;
  304.     }
  305. #endif
  306. //    unsigned int operator += (unsigned int s)
  307.     unsigned int addSize(unsigned int s)
  308.     {
  309.         return setSize(size+s);
  310.     }
  311. //    unsigned int operator -= (unsigned int s)
  312.     unsigned int subSize(unsigned int s)
  313.     {
  314.         if (s > size)
  315.             s = size;
  316.         s = size - s;
  317.         unsigned int sz = setSize(s);
  318.         if (isstr && s)
  319.             data[s-1] = 0;
  320.         return sz;
  321.     }
  322. };
  323.  
  324. class dbString : public dbData
  325. {
  326. public:
  327.     dbString(void) : dbData(1) { }
  328.     dbString(dbData& D) : dbData((char*)D, 1) { }
  329.     dbString(dbString& D) : dbData(D, 1) { }
  330.     dbString(char* s) : dbData(s, 1) { }
  331.     dbString& operator = (char* s)
  332.     {
  333.         cpy(s);
  334.         return *this;
  335.     }
  336.     dbString& operator = (dbData& d)
  337.     {
  338.         cpy(d);
  339.         return *this;
  340.     }
  341.     int operator == (char* str)
  342.     {
  343.         return !strcmp(data, str);
  344.     }
  345.     int operator == (dbString& d)
  346.     {
  347.         return !strcmp(data, d.data);
  348.     }
  349. };
  350. #endif
  351.