cmt_string.cxx Source File

Main Page Class Hierarchy Compound List File List Compound Members File Members

# cmt_string.cxx

Go to the documentation of this file.

    00001
    00002 #include <stdio.h>
    00003 #include <stdlib.h>
    00004 #include "cmt_std.h"
    00005 #include "cmt_string.h"
    00006
    00007 cmt_string::cmt_string ()
    00008 {
    00009   _data = 0;
    00010   _allocated = 0;
    00011   _size = 0;
    00012 }
    00013
    00014 cmt_string::cmt_string (int n)
    00015 {
    00016   _data = 0;
    00017   _allocated = 0;
    00018   _size = 0;
    00019   allocate (n + 1);
    00020 }
    00021
    00022 cmt_string::cmt_string (char c)
    00023 {
    00024   _data = 0;
    00025   _allocated = 0;
    00026   _size = 0;
    00027
    00028   allocate (2);
    00029
    00030   _data[0] = c;
    00031   _data[1] = 0;
    00032   _size = 1;
    00033 }
    00034
    00035 cmt_string::cmt_string (const char* text)
    00036 {
    00037   _data = 0;
    00038   _allocated = 0;
    00039   _size = 0;
    00040
    00041   if (text != 0)
    00042     {
    00043       _size = strlen (text);
    00044       allocate (_size + 1);
    00045       strcpy (_data, text);
    00046     }
    00047 }
    00048
    00049 cmt_string::cmt_string (const cmt_string& other)
    00050 {
    00051   const char* text = other._data;
    00052
    00053   _data = 0;
    00054   _allocated = 0;
    00055   _size = 0;
    00056
    00057   if (text != 0)
    00058     {
    00059       _size = strlen (text);
    00060       allocate (_size + 1);
    00061       strcpy (_data, text);
    00062     }
    00063 }
    00064
    00065 cmt_string::~cmt_string ()
    00066 {
    00067   if (_data != 0)
    00068     {
    00069 #ifdef CMT_USE_NEW_DELETE
    00070       delete[] _data;
    00071 #else
    00072       free (_data);
    00073 #endif
    00074     }
    00075   _data = 0;
    00076   _allocated = 0;
    00077   _size = 0;
    00078 }
    00079
    00080   //
    00081   // Operators
    00082   //
    00083 cmt_string& cmt_string::operator = (char c)
    00084 {
    00085   allocate (2);
    00086
    00087   _data[0] = c;
    00088   _data[1] = 0;
    00089
    00090   _size = 1;
    00091
    00092   return (*this);
    00093 }
    00094
    00095 cmt_string& cmt_string::operator = (const char* text)
    00096 {
    00097   if (text == _data) return (*this);
    00098
    00099   if (text != 0)
    00100     {
    00101       _size = strlen (text);
    00102       allocate (_size + 1);
    00103       strcpy (_data, text);
    00104     }
    00105   else
    00106     {
    00107       _size = 0;
    00108
    00109       if (_data != 0)
    00110         {
    00111           _data[0] = 0;
    00112         }
    00113     }
    00114
    00115   return (*this);
    00116 }
    00117
    00118 cmt_string& cmt_string::operator = (const cmt_string& other)
    00119 {
    00120   const char* text = other._data;
    00121   cmt_string& me = *this;
    00122   me = text;
    00123   return (me);
    00124 }
    00125
    00126 cmt_string::operator const char* () const
    00127 {
    00128   if (_data == 0) return ("");
    00129   else return (_data);
    00130 }
    00131
    00132 const char* cmt_string::c_str () const
    00133 {
    00134   if (_data == 0) return ("");
    00135   else return (_data);
    00136 }
    00137
    00138 /*
    00139 char* cmt_string::c_str ()
    00140 {
    00141   return (_data);
    00142 }
    00143 */
    00144
    00145 void cmt_string::operator += (char c)
    00146 {
    00147   extend (2);
    00148
    00149   char temp[2] = { c, 0 };
    00150
    00151   strcat (&_data[_size], temp);
    00152   _size++;
    00153 }
    00154
    00155 void cmt_string::operator += (const char* text)
    00156 {
    00157   if (text == 0) return;
    00158
    00159   int s = strlen (text);
    00160   extend (s + 1);
    00161
    00162   strcat (&_data[_size], text);
    00163   _size += s;
    00164 }
    00165
    00166 void cmt_string::operator += (const cmt_string& other)
    00167 {
    00168   const char* text = other._data;
    00169   cmt_string& me = *this;
    00170
    00171   me += text;
    00172 }
    00173
    00174 cmt_string cmt_string::operator + (char c) const
    00175 {
    00176   cmt_string result (_data);
    00177   result += c;
    00178
    00179   return (result);
    00180 }
    00181
    00182 cmt_string cmt_string::operator + (const char* text) const
    00183 {
    00184   cmt_string result (_data);
    00185   result += text;
    00186
    00187   return (result);
    00188 }
    00189
    00190 cmt_string cmt_string::operator + (const cmt_string& other) const
    00191 {
    00192   cmt_string result (_data);
    00193   result += other;
    00194
    00195   return (result);
    00196 }
    00197
    00198 char cmt_string::operator [] (int index) const
    00199 {
    00200   if ((_data == 0) ||
    00201       (index < 0) ||
    00202       (index >= _size))
    00203     {
    00204       return (0);
    00205     }
    00206   else
    00207     {
    00208       return (_data[index]);
    00209     }
    00210 }
    00211
    00212 char& cmt_string::operator [] (int index)
    00213 {
    00214   if ((_data == 0) ||
    00215       (index < 0) ||
    00216       (index >= _size))
    00217     {
    00218       static char temp;
    00219       return (temp);
    00220     }
    00221   else
    00222     {
    00223       return (_data[index]);
    00224     }
    00225 }
    00226
    00227 int cmt_string::size () const
    00228 {
    00229   if (_data == 0) return (0);
    00230   return (_size);
    00231 }
    00232
    00233 int cmt_string::size ()
    00234 {
    00235   if (_data == 0) return (0);
    00236   return (_size);
    00237 }
    00238
    00239 void cmt_string::resize (int n)
    00240 {
    00241   allocate (n + 1);
    00242 }
    00243
    00244 int cmt_string::find (char c) const
    00245 {
    00246   if (_data == 0) return (npos);
    00247
    00248   char* p = strchr (_data, c);
    00249   if (p == 0) return (npos);
    00250   return (p - _data);
    00251 }
    00252
    00253 int cmt_string::find (const char* text) const
    00254 {
    00255   if (_data == 0) return (npos);
    00256   if (text == 0) return (npos);
    00257
    00258   char* p = strstr (_data, text);
    00259   if (p == 0) return (npos);
    00260   return (p - _data);
    00261 }
    00262
    00263 int cmt_string::find (const cmt_string& other) const
    00264 {
    00265   const char* text = other._data;
    00266   return (find (text));
    00267 }
    00268
    00269 int cmt_string::find (int pos, char c) const
    00270 {
    00271   if (_data == 0) return (npos);
    00272   if (pos < 0) return (npos);
    00273   if (pos >= _size) return (npos);
    00274
    00275   char* p = strchr (&_data[pos], c);
    00276   if (p == 0) return (npos);
    00277   return (p - _data);
    00278 }
    00279
    00280 int cmt_string::find (int pos, const char* text) const
    00281 {
    00282   if (_data == 0) return (npos);
    00283   if (text == 0) return (npos);
    00284   if (pos < 0) return (npos);
    00285   if (pos >= _size) return (npos);
    00286
    00287   char* p = strstr (&_data[pos], text);
    00288   if (p == 0) return (npos);
    00289   return (p - _data);
    00290 }
    00291
    00292 int cmt_string::find (int pos, const cmt_string& other) const
    00293 {
    00294   const char* text = other._data;
    00295   return (find (pos, text));
    00296 }
    00297
    00298 int cmt_string::find_last_of (char c) const
    00299 {
    00300   if (_data == 0) return (npos);
    00301
    00302   char* p = strrchr (_data, c);
    00303   if (p == 0) return (npos);
    00304   return (p - _data);
    00305 }
    00306
    00307 int cmt_string::find_last_of (const char* text) const
    00308 {
    00309   if (_data == 0) return (npos);
    00310   if (text == 0) return (npos);
    00311
    00312   char* ptr = _data;
    00313   char* last = 0;
    00314   char* p;
    00315   while ((p = strstr (ptr, text)) != 0)
    00316     {
    00317       last = p;
    00318       ptr = p + 1;
    00319     }
    00320   if (last == 0) return (npos);
    00321   return (last - _data);
    00322 }
    00323
    00324 int cmt_string::find_last_of (const cmt_string& other) const
    00325 {
    00326   const char* text = other._data;
    00327   return (find_last_of (text));
    00328 }
    00329
    00330 void cmt_string::erase (int pos)
    00331 {
    00332   if ((_data == 0) ||
    00333       (pos < 0) ||
    00334       (pos >= _size))
    00335     {
    00336       return;
    00337     }
    00338   else
    00339     {
    00340       _data[pos] = 0;
    00341       _size = pos;
    00342     }
    00343 }
    00344
    00345 void cmt_string::erase (int pos, int length)
    00346 {
    00347   if ((_data == 0) ||
    00348       (pos < 0) ||
    00349       (pos >= _size))
    00350     {
    00351       return;
    00352     }
    00353   else
    00354     {
    00355       if ((pos + length) >= _size)
    00356         {
    00357           _data[pos] = 0;
    00358           _size = pos;
    00359         }
    00360       else
    00361         {
    00362           strcpy (&_data[pos], &_data[pos + length]);
    00363           _size -= length;
    00364         }
    00365     }
    00366 }
    00367
    00368
    00369 void cmt_string::replace (const char* pattern, const char* replacement)
    00370 {
    00371   if (_data == 0) return;
    00372   if (_size == 0) return;
    00373   if (pattern == 0) return;
    00374
    00375   if (replacement == 0) replacement = "";
    00376
    00377   int pattern_length = strlen (pattern);
    00378
    00379   if (pattern_length == 0) return;
    00380
    00381   int replacement_length = strlen (replacement);
    00382   int delta = replacement_length - pattern_length;
    00383
    00384   int pos;
    00385
    00386   if ((pos = find (pattern)) != npos)
    00387     {
    00388       if (delta > 0)
    00389         {
    00390             // string will be enlarged
    00391           extend (delta);
    00392
    00393           char* src = &_data[_size];
    00394           char* dest = src + delta;
    00395           while (src > &_data[pos])
    00396             {
    00397               *dest = *src;
    00398               src--;
    00399               dest--;
    00400             }
    00401         }
    00402       else if (delta < 0)
    00403         {
    00404             // string will be shortened
    00405
    00406           char* src = &_data[pos + pattern_length];
    00407           char* dest = src + delta;
    00408           while (*src != 0)
    00409             {
    00410               *dest = *src;
    00411               src++;
    00412               dest++;
    00413             }
    00414           *dest = *src;
    00415         }
    00416
    00417       strncpy (&_data[pos], replacement, replacement_length);
    00418
    00419       _size += delta;
    00420     }
    00421 }
    00422
    00423 void cmt_string::replace (const cmt_string& pattern,
    00424                           const cmt_string& replacement)
    00425 {
    00426   const char* p_text = pattern._data;
    00427   const char* r_text = replacement._data;
    00428   cmt_string& me = *this;
    00429
    00430   me.replace (p_text, r_text);
    00431 }
    00432
    00433 void cmt_string::replace_all (const char* pattern, const char* replacement)
    00434 {
    00435   if (_data == 0) return;
    00436   if (_size == 0) return;
    00437   if (pattern == 0) return;
    00438
    00439   if (replacement == 0) replacement = "";
    00440
    00441   int pattern_length = strlen (pattern);
    00442   if (pattern_length == 0) return;
    00443
    00444   int replacement_length = strlen (replacement);
    00445   int delta = replacement_length - pattern_length;
    00446
    00447   int pos = 0;
    00448
    00449   while ((pos = find (pos, pattern)) != npos)
    00450     {
    00451       if (delta > 0)
    00452         {
    00453             // string will be enlarged
    00454           extend (delta);
    00455
    00456           char* src = &_data[_size];
    00457           char* dest = src + delta;
    00458           while (src > &_data[pos])
    00459             {
    00460               *dest = *src;
    00461               src--;
    00462               dest--;
    00463             }
    00464         }
    00465       else if (delta < 0)
    00466         {
    00467             // string will be shortened
    00468
    00469           char* src = &_data[pos + pattern_length];
    00470           char* dest = src + delta;
    00471           while (*src != 0)
    00472             {
    00473               *dest = *src;
    00474               src++;
    00475               dest++;
    00476             }
    00477           *dest = *src;
    00478         }
    00479
    00480       strncpy (&_data[pos], replacement, replacement_length);
    00481       pos += replacement_length;
    00482       _size += delta;
    00483     }
    00484 }
    00485
    00486 void cmt_string::replace_all (const cmt_string& pattern,
    00487                               const cmt_string& replacement)
    00488 {
    00489   const char* p_text = pattern._data;
    00490   const char* r_text = replacement._data;
    00491   cmt_string& me = *this;
    00492
    00493   me.replace_all (p_text, r_text);
    00494 }
    00495
    00496 void cmt_string::trim ()
    00497 {
    00498   if (size () == 0) return;
    00499
    00500   int i = 0;
    00501
    00502   i = strspn (_data, " \t");
    00503   if (i > 0) erase (0, i);
    00504
    00505   for (i = _size - 1; i >= 0; i--)
    00506     {
    00507       char c = _data[i];
    00508       if ((c == ' ') || (c == '\t')) continue;
    00509       erase (i + 1);
    00510       break;
    00511     }
    00512 }
    00513
    00514 cmt_string cmt_string::substr (int pos) const
    00515 {
    00516   if ((_data == 0) ||
    00517       (pos < 0) ||
    00518       (pos >= _size))
    00519     {
    00520       return ((cmt_string) "");
    00521     }
    00522   else
    00523     {
    00524       return ((cmt_string) &_data[pos]);
    00525     }
    00526 }
    00527
    00528 cmt_string cmt_string::substr (int pos, int length) const
    00529 {
    00530   if ((_data == 0) ||
    00531       (pos < 0) ||
    00532       (pos >= _size))
    00533     {
    00534       return ((cmt_string) "");
    00535     }
    00536   else
    00537     {
    00538       cmt_string result (&_data[pos]);
    00539       result.erase (length);
    00540       return (result);
    00541     }
    00542 }
    00543
    00544 void cmt_string::substr (int pos, cmt_string& dest) const
    00545 {
    00546   if ((_data == 0) ||
    00547       (pos < 0) ||
    00548       (pos >= _size))
    00549     {
    00550       dest = "";
    00551     }
    00552   else
    00553     {
    00554       dest = (const char*) &_data[pos];
    00555     }
    00556 }
    00557
    00558 void cmt_string::substr (int pos, int length, cmt_string& dest) const
    00559 {
    00560   if ((_data == 0) ||
    00561       (pos < 0) ||
    00562       (pos >= _size))
    00563     {
    00564       dest = "";
    00565     }
    00566   else
    00567     {
    00568       dest = (const char*) &_data[pos];
    00569       dest.erase (length);
    00570     }
    00571 }
    00572
    00573 bool cmt_string::operator < (const char* text) const
    00574 {
    00575   if (text == 0) return (false);
    00576   if (_data == 0) return (false);
    00577
    00578   if (strcmp (_data, text) < 0) return (true);
    00579   return (false);
    00580 }
    00581
    00582 bool cmt_string::operator < (const cmt_string& other) const
    00583 {
    00584   const char* text = other._data;
    00585   const cmt_string& me = *this;
    00586
    00587   return (me < text);
    00588 }
    00589
    00590 bool cmt_string::operator == (const char* text) const
    00591 {
    00592   if (text == 0)
    00593     {
    00594       if (_data == 0) return (true);
    00595       if (_size == 0) return (true);
    00596       return (false);
    00597     }
    00598   if (_data == 0)
    00599     {
    00600       if (text == 0) return (true);
    00601       if (strlen (text) == 0) return (true);
    00602       return (false);
    00603     }
    00604
    00605   if (strcmp (_data, text) == 0) return (true);
    00606   return (false);
    00607 }
    00608
    00609 bool cmt_string::operator == (const cmt_string& other) const
    00610 {
    00611   const char* text = other._data;
    00612   const cmt_string& me = *this;
    00613
    00614   return (me == text);
    00615 }
    00616
    00617 bool cmt_string::operator != (const char* text) const
    00618 {
    00619   const cmt_string& me = *this;
    00620
    00621   if (!(me == text)) return (true);
    00622   return (false);
    00623 }
    00624
    00625 bool cmt_string::operator != (const cmt_string& other) const
    00626 {
    00627   const char* text = other._data;
    00628   const cmt_string& me = *this;
    00629
    00630   return (me != text);
    00631 }
    00632
    00633 bool cmt_string::operator > (const char* text) const
    00634 {
    00635   if (text == 0) return (false);
    00636   if (_data == 0) return (false);
    00637
    00638   if (strcmp (_data, text) > 0) return (true);
    00639   return (false);
    00640 }
    00641
    00642 bool cmt_string::operator > (const cmt_string& other) const
    00643 {
    00644   const char* text = other._data;
    00645   const cmt_string& me = *this;
    00646
    00647   return (me > text);
    00648 }
    00649
    00650 void cmt_string::extend (int n)
    00651 {
    00652   if (_data != 0) n += _size;
    00653   allocate (n);
    00654 }
    00655
    00656 void cmt_string::allocate (int n)
    00657 {
    00658   if ((n + 1) > _allocated)
    00659     {
    00660       static const int quantum = 128;
    00661       int frames = ((n + 1)/quantum) + 1;
    00662       _allocated = frames * quantum;
    00663
    00664 #ifdef CMT_USE_NEW_DELETE
    00665       char* new_data = new char [_allocated + 1];
    00666 #else
    00667       char* new_data = (char*) malloc (_allocated + 1);
    00668 #endif
    00669
    00670
    00671       if (_data != 0)
    00672         {
    00673           strcpy (new_data, _data);
    00674
    00675 #ifdef CMT_USE_NEW_DELETE
    00676           delete[] _data;
    00677 #else
    00678           free (_data);
    00679 #endif
    00680
    00681           _data = new_data;
    00682         }
    00683       else
    00684         {
    00685           new_data[0] = 0;
    00686         }
    00687
    00688       _data = new_data;
    00689     }
    00690 }
    00691
    00692 ostream& operator << (ostream& o, const cmt_string& s)
    00693 {
    00694   o << (const char*) s;
    00695   return (o);
    00696 }
    00697
    00698 cmt_string operator + (const char* text, const cmt_string& s)
    00699 {
    00700   cmt_string result = text;
    00701   result += s;
    00702   return (result);
    00703 }
    00704
    00705 cmt_string operator + (char c, const cmt_string& s)
    00706 {
    00707   cmt_string result = c;
    00708   result += s;
    00709   return (result);
    00710 }
    00711
    00712 bool cmt_string::read (const cmt_string& file_name)
    00713 {
    00714   FILE* f = fopen (file_name.c_str (), "rb");
    00715   if (f != NULL)
    00716     {
    00717       fseek (f, 0L, SEEK_END);
    00718       int size = ftell (f);
    00719       fseek (f, 0L, SEEK_SET);
    00720
    00721       allocate (size + 1);
    00722
    00723       fread (&_data[0], size, 1, f);
    00724
    00725       _data[size] = 0;
    00726       _size = size;
    00727
    00728       fclose (f);
    00729
    00730       return (true);
    00731     }
    00732   else
    00733     {
    00734       cmt_string& me = *this;
    00735       me = "";
    00736
    00737       return (false);
    00738     }
    00739 }
    00740
    00741 bool cmt_string::write (const cmt_string& file_name) const
    00742 {
    00743   FILE* f = fopen (file_name.c_str (), "wb");
    00744   if (f != NULL)
    00745     {
    00746       write (f);
    00747       fclose (f);
    00748       return (true);
    00749     }
    00750   else
    00751     {
    00752       return (false);
    00753     }
    00754 }
    00755
    00756 void cmt_string::write (FILE* f) const
    00757 {
    00758   fwrite (&_data[0], size (), 1, f);
    00759 }
    00760
    00761 void cmt_string::write (ostream& output)
    00762 {
    00763   output.write (&_data[0], size ());
    00764 }
    00765