home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1995 August / NEBULA.bin / SourceCode / MiscKit1.2.6 / Source / MiscStringModification.m < prev    next >
Encoding:
Text File  |  1994-05-19  |  9.2 KB  |  389 lines
  1. //
  2. //    MiscStringModification.m
  3. //        Written by Don Yacktman (c) 1993 by Don Yacktman.
  4. //                Version 1.95  All rights reserved.
  5. //        This notice may not be removed from this source code.
  6. //
  7. //    This object is included in the MiscKit by permission from the author
  8. //    and its use is governed by the MiscKit license, found in the file
  9. //    "LICENSE.rtf" in the MiscKit distribution.  Please refer to that file
  10. //    for a list of all applicable permissions and restrictions.
  11. //    
  12.  
  13. #import <misckit/MiscString.h>
  14.  
  15. @implementation MiscString(Modification)
  16.  
  17. // This category is composed of methods which modify a MiscString in
  18. // various ways (case conversion, trimming whitespace, deleting portions
  19. // of the string, and so on).
  20.  
  21. - setStringValue:(const char *)aString
  22. {
  23.     return [self setStringValue:aString fromZone:[self zone]];
  24. }
  25.  
  26. - setStringValue:(const char *)aString fromZone:(NXZone *)zone
  27. {
  28.     if (!aString) return self; // use -freeString to set to "NULL"
  29.     // Note that I could have used NXCopyStringBufferFromZone() here
  30.     // instead.  This works just as well, but it may be slower...
  31.     // I haven't checked that out, though.  It might be worth doing.
  32.     [self allocateBuffer:(strlen(aString)+1) fromZone:zone];
  33.     strcpy(buffer, aString);
  34.     length = strlen(buffer);
  35.     return self;
  36. }
  37.  
  38. - setStringValue:(const char *)aString n:(int)n
  39. {
  40.     return [self setStringValue:aString n:n fromZone:[self zone]];
  41. }
  42.  
  43. - setStringValue:(const char *)aString n:(int)n fromZone:(NXZone *)zone
  44. {
  45.     char *buf = NULL;
  46.     if ((aString) && (n > 0))  {
  47.         NX_MALLOC(buf, char, n + 1);
  48.         strncpy(buf, aString, n);
  49.         buf[n]='\0';
  50.     }
  51.     [self setStringValue:buf fromZone:zone];
  52.     NX_FREE(buf);
  53.     return self;
  54. }
  55.  
  56. - setFromFormat:(const char *)formatStr, ...
  57. // Sets the string from and printf style format string and arguments.
  58. {
  59.     va_list param_list;
  60.     char *buf;
  61.  
  62.     va_start(param_list, formatStr);
  63.     buf = MiscBuildStringFromFormatV(formatStr, param_list);
  64.     va_end(param_list);
  65.     [self setStringValue:buf];
  66.     NX_FREE(buf);
  67.     return self;
  68. }
  69.  
  70. - setIntValue:(int)val
  71. // Sets the string by converting the given int to a string.
  72. {
  73.     return [self setFromFormat:"%d", val];
  74. }
  75.  
  76. - setFloatValue:(float)val
  77. // Sets the string by converting the given float to a string.
  78. {
  79.     return [self setFromFormat:"%f", val];
  80. }
  81.  
  82. - setDoubleValue:(double)val
  83. // Sets the string by converting the given double to a string.
  84. {
  85.     return [self setFromFormat:"%f", val];
  86. }
  87.  
  88. - sprintf:(const char *)formatStr, ...
  89. // Sets the strings contents as the result of printf'ing with the
  90. // given format string and arguments.  Same as setFromFormat:, ...
  91. {
  92.     va_list param_list;
  93.     char *buf;
  94.     
  95.     va_start(param_list, formatStr);
  96.     buf = MiscBuildStringFromFormatV(formatStr, param_list);
  97.     va_end(param_list);
  98.     [self setStringValue:buf];
  99.     NX_FREE(buf);
  100.     return self;
  101. }
  102.  
  103. - takeStringValueFrom:sender
  104. { // if no string value, return nil; the user is expecting a changed string
  105.     if (!sender) return [self freeString]; // this seems reasonable...
  106.         // but maybe I should just return nil instead...
  107.     if (![sender respondsTo:@selector(stringValue)]) return nil;
  108.     return [self setStringValue:[sender stringValue] fromZone:[self zone]];
  109. }
  110.  
  111. - takeStringValueFrom:sender fromZone:(NXZone *)zone
  112. {
  113.     if (![sender respondsTo:@selector(stringValue)]) return nil;
  114.     return [self setStringValue:[sender stringValue] fromZone:zone];
  115. }
  116.  
  117. - takeIntValueFrom:sender
  118. {
  119.     if (![sender respondsTo:@selector(intValue)]) return nil;
  120.     [self setIntValue:[sender intValue]];
  121.     return self;
  122. }
  123.  
  124. - takeFloatValueFrom:sender
  125. {
  126.     if (![sender respondsTo:@selector(floatValue)]) return nil;
  127.     [self setFloatValue:[sender floatValue]];
  128.     return self;
  129. }
  130.  
  131. - takeDoubleValueFrom:sender
  132. {
  133.     if (![sender respondsTo:@selector(doubleValue)]) return nil;
  134.     [self setDoubleValue:[sender doubleValue]];
  135.     return self;
  136. }
  137.  
  138. - trimLeadSpaces
  139. { // removes any leading spaces from buffer
  140.     int i = 0;
  141.     id tmpStr;
  142.  
  143.     if (!buffer) return self;
  144.     if (length < 1) return self;
  145.     while (buffer[i] == ' ') i++;
  146.     if (i==0) return self;
  147.     tmpStr = [self right:length-i];
  148.     [self takeStringValueFrom:tmpStr];
  149.     [tmpStr free];
  150.     return self;
  151. }
  152.  
  153. - trimTailSpaces
  154. // removes any trailing spaces from buffer
  155. {
  156.     int i = length;
  157.     id tmpStr;
  158.  
  159.     if (!buffer) return self;
  160.     if (i < 1) return self;
  161.     while (buffer[i-1] == ' ') i--;
  162.     if (i==length) return self;
  163.     tmpStr = [self left:i];
  164.     [self takeStringValueFrom:tmpStr];
  165.     [tmpStr free];
  166.     return self;
  167. }
  168.  
  169. - trimSpaces
  170. // takes off leading and trailing spaces of the buffer
  171. {
  172.     return [[self trimLeadSpaces] trimTailSpaces];
  173. }
  174.  
  175. - trimLeadWhiteSpaces
  176. // removes any leading white space from buffer
  177. { 
  178.     int i = 0;
  179.     id tmpStr;
  180.     
  181.     if (!buffer) return self;
  182.     if (length < 1) return self;
  183.     while (NXIsSpace(buffer[i])) i++;
  184.     if (i==0) return self;
  185.     tmpStr = [self right:length-i];
  186.     [self takeStringValueFrom:tmpStr];
  187.     [tmpStr free];
  188.     return self;
  189. }
  190.  
  191. - trimTailWhiteSpaces
  192. // removes any leading white space from buffer
  193. { 
  194.     int i = length;
  195.     id tmpStr;
  196.     
  197.     if (!buffer) return self;
  198.     if (i < 1) return self;
  199.     while (NXIsSpace(buffer[i-1])) i--;
  200.     if (i==length) return self;
  201.     tmpStr = [self left:i];
  202.     [self takeStringValueFrom:tmpStr];
  203.     [tmpStr free];
  204.     return self;
  205. }
  206.  
  207. - trimWhiteSpaces
  208. // takes off leading and trailing spaces of the buffer
  209. {
  210.     return [[self trimLeadWhiteSpaces] trimTailWhiteSpaces];
  211. }
  212.  
  213. - squashSpaces
  214. {
  215.   int count = 0;
  216.   id tempStr;
  217.   
  218.   if (!buffer) return self;
  219.   [self trimSpaces];
  220.   tempStr = [[[[self class] alloc] init] allocateBuffer:length];
  221.   while (count<length) {
  222.     while ((count<length) && (buffer[count]!=' ')) {
  223.       [tempStr addChar:buffer[count]];
  224.       count++;
  225.      }
  226.     if ((count<length) && (buffer[count] == ' ')) {
  227.       [tempStr addChar:buffer[count]];
  228.       count++;
  229.      }
  230.     if ((count<length) && (buffer[count]==' ') && 
  231.        ((buffer[count-2] == ':') || (buffer[count-2] =='.'))) {
  232.          [tempStr addChar:buffer[count]];
  233.          count++;
  234.      }
  235.     while (buffer[count]==' ') count++;
  236.    }
  237.   [self takeStringValueFrom:tempStr];
  238.   [tempStr free];
  239.   return self;
  240. }
  241.  
  242. - reverse
  243. // reverses the characters in the buffer.  If it's a palindrome, you won't
  244. // notice much of a difference :-)
  245. {
  246.     char tmp[length+1];
  247.     int i, j=0;
  248.   
  249.     if (length <= 1) return self;
  250.     for (i=length-1; i>=0; i--) {
  251.         tmp[j] = buffer[i];
  252.         j++;
  253.     }
  254.     tmp[length] = 0;
  255.     if (length != 0) [self setStringValue:tmp];
  256.     return self;
  257. }
  258.  
  259. - toUpper
  260. // converts any lowercase characters in buffer to uppercase
  261. {
  262.     int i;
  263.     for (i=0; i<length; i++) {
  264.         if (NXIsLower(buffer[i])) buffer[i] = NXToUpper(buffer[i]);
  265.     }
  266.     return self;
  267. }
  268.  
  269. - toLower
  270. // converts any uppercase chars in buffer to lowercase
  271. {
  272.     int i;
  273.     for (i=0; i<length; i++) {
  274.         if (NXIsUpper(buffer[i])) buffer[i] = NXToLower(buffer[i]);
  275.     }
  276.     return self;
  277. }
  278.  
  279. - invertCases
  280. {
  281.     int i;
  282.     for (i=0; i<length; i++) {
  283.         if (NXIsUpper(buffer[i])) buffer[i] = NXToLower(buffer[i]);
  284.         else buffer[i] = NXToUpper(buffer[i]);
  285.     }
  286.     return self;
  287. }
  288.  
  289. - capitalizeEachWord
  290. { // ***** it might be nice to NOT capitalize words like "a" "an" and "the"
  291.     // so that capitalizations follw the style of titles, etc.
  292.     int i = 0;
  293.     if (!buffer) return 0;  
  294.     while (i <= length) {
  295.         while ((NXIsSpace(buffer[i])) && (i <= length)) i++;
  296.         if (i < length) buffer[i] = NXToUpper(buffer[i]);
  297.         while ((!NXIsSpace(buffer[i])) && (i <= length)) i++;
  298.     }
  299.     return self;
  300. }
  301.  
  302. - removeFrom:(int)index length:(int)len
  303. { // to avoid memory leaks, this should NEVER return nil!
  304.   id temp1,temp2;
  305.   
  306.   if (!buffer) return self;    // everything's already gone
  307.   if (len <= 0) return self; // noting to remove
  308.   // DAY: should I presume to fix index<0 like so? or just index = 0?
  309.   // or just return self?
  310.   if (index < 0) { len += index; index = 0; if (len <= 0) return self; }
  311.   if (index > length - 1) return self; // nothing out there
  312.   temp1 = [self left:index];
  313.   if (!temp1) temp1 = [[[self class] alloc] init];
  314.   temp2 = [self midFrom:index+len to:length];
  315.   [temp1 concatenate:temp2];
  316.   [self takeStringValueFrom:temp1];
  317.   [temp1 free];
  318.   [temp2 free];
  319.   return self;
  320. }
  321.  
  322. - removeFrom:(int)start to:(int)end
  323. {
  324.   return [self removeFrom:start length:end-start+1];
  325. }
  326.  
  327. - (int)gets
  328. {
  329.   char c;
  330.   [self setStringValue:""];
  331.   
  332.   while (((c = getchar()) != '\n') && (c != EOF)) {
  333.     if (length == _length-1) [self setCapacity:length*2];
  334.     [self addChar:c];
  335.    }
  336.   return (c == '\n')? 0:EOF;
  337. }
  338.  
  339. - (int)fgets:(FILE *)fd keepNewline:(BOOL)keepit
  340. {
  341.   char c;
  342.   [self setStringValue:""];
  343.   
  344.   while (((c = fgetc(fd)) != '\n') && (c != EOF)) {
  345.     if (length == _length-1) [self setCapacity:length*2];
  346.     [self addChar:c];
  347.    }
  348.   if (keepit && (c == '\n')) [self addChar:'\n']; //don't add EOF
  349.   return (c == '\n')? 0:EOF;
  350. }
  351.  
  352. - (int)fgets:(FILE *)fd
  353. {
  354.   return [self fgets:fd keepNewline:YES];
  355. }
  356.  
  357.  
  358. - (int)streamGets:(NXStream *)stream keepNewline:(BOOL)keepit
  359. {
  360.   char c = '\0';
  361.   [self setStringValue:""];
  362.   
  363.   while (!NXAtEOS(stream) && ((c = NXGetc(stream)) != '\n') && (c != EOF)) {
  364.     if (length == _length-1) [self setCapacity:length*2];
  365.     [self addChar:c];
  366.    }
  367.   if (keepit && (c == '\n')) [self addChar:'\n']; //don't add EOF
  368.   return (c == '\n')? 0:EOF;
  369. }
  370.  
  371. - (int)streamGets:(NXStream *)stream
  372. {
  373.   return [self streamGets:stream keepNewline:YES];
  374. }
  375.  
  376. - padToLength:(int)len withChar:(char)aChar
  377. {
  378.   int i;
  379.   
  380.   for (i=length;i<len;i++) {
  381.     if (length == _length-1) [self setCapacity:length*2];
  382.     [self addChar:aChar];
  383.    }
  384.   return self;
  385. }
  386.  
  387. // need a removePart:... series like the extract part stuff.
  388. @end
  389.