home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1995 August / NEBULA.mdf / SourceCode / MiscKit1.2.6 / Source / MiscStringReplacing.m < prev    next >
Encoding:
Text File  |  1994-05-28  |  6.8 KB  |  253 lines
  1. //
  2. //    MiscStringReplacing.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(Replacing)
  16.  
  17. // This category is composed of methods which modify a MiscString
  18. // by replacing a character or substring with a new character or
  19. // substring.
  20.  
  21. - replaceFrom:(int)start length:(int)len with:(const char *)aString
  22. {
  23.   return [[self removeFrom:start length:len] insert:aString at:start];
  24. }
  25.  
  26. - replaceFrom:(int)start to:(int)end with:(const char *)aString
  27. {
  28.   return [[self removeFrom:start to:end] insert:aString at:start];
  29. }
  30.  
  31. - replaceFrom:(int)start length:(int)len withString:(id)sender
  32. {
  33.   if (![sender respondsTo:@selector(stringValue)]) return self;
  34.   return [self replaceFrom:start length:len with:[sender stringValue]];
  35. }
  36.  
  37. - replaceFrom:(int)start to:(int)end withString:(id)sender
  38. {
  39.   if (![sender respondsTo:@selector(stringValue)]) return self;
  40.   return [self replaceFrom:start to:end with:[sender stringValue]];
  41. }
  42.  
  43. - replace:(const char *)subString with:(const char *)newString
  44. {
  45.   const char *spot;
  46.   
  47.   if ((spot = [self strstr:subString]))
  48.     [self replaceFrom:(int)(spot-buffer) length:strlen(subString) with:newString];
  49.   return self;
  50. }
  51.  
  52. - replace:(const char *)subString withString:(id)sender
  53. {
  54.   if (![sender respondsTo:@selector(stringValue)]) return self;
  55.   return [self replace:subString with:[sender stringValue]];
  56. }
  57.  
  58. - replaceCharAt:(int)index withChar:(char)aChar
  59. {    // no change if index is out of range.
  60.     // Other option is to limit index to be in range.  which is better?
  61.   if ((index < 0) || (index >= length)) return self;
  62.  
  63.   if (aChar == 0) return self; // should this return nil? DAY: leave it.
  64.  
  65.   buffer[index] = aChar;
  66.   return self;
  67. }
  68.  
  69. - replaceFrom:(int)start length:(int)len withChar:(char)aChar
  70. {
  71.     id retval,tempStr;
  72.    
  73.     if (aChar == 0) return nil;
  74.     tempStr = [[[[self class] alloc] init] addChar:aChar];
  75.     retval = [self  replaceFrom:start length:len
  76.                     withString:tempStr];
  77.     [tempStr free];
  78.     return retval;
  79. }
  80.  
  81. - replaceFrom:(int)start to:(int)end withChar:(char)aChar
  82. {
  83.   return [self replaceFrom:start length:end-start+1 withChar:aChar];
  84. }
  85.  
  86. - replaceEveryOccurrenceOfChars:(const char *)aString
  87.         with:(const char *)replaceString
  88. {
  89.     return [self replaceEveryOccurrenceOfChars:aString
  90.             with:replaceString caseSensitive:YES];
  91. }
  92.  
  93. - replaceEveryOccurrenceOfChars:(const char *)aString
  94.         with:(const char *)replaceString caseSensitive:(BOOL)sense
  95. {
  96.     int i;
  97.     id tempStr;
  98.  
  99.     if (!aString) return self;
  100.         // I think a null replace string should be allowed here...
  101.  
  102.     tempStr = [MiscString newWithString:aString];
  103.     for (i=length-1;i>=0;i--)
  104.     if ([tempStr spotOf:buffer[i] caseSensitive:sense] != -1)
  105.         [self replaceFrom:i to:i with:replaceString];
  106.  
  107.     [tempStr free];
  108.     return self;
  109. }
  110.  
  111. - replaceEveryOccurrenceOfChars:(const char *)aString
  112.         withChar:(char)replaceChar
  113. {
  114.     return [self replaceEveryOccurrenceOfChars:aString
  115.             withChar:replaceChar caseSensitive:YES];
  116. }
  117.  
  118. - replaceEveryOccurrenceOfChars:(const char *)aString
  119.         withChar:(char)replaceChar caseSensitive:(BOOL)sense
  120. {
  121.     int i;
  122.     id tempStr;
  123.  
  124.     if (!aString) return self;
  125.     if (!replaceChar) return nil;  //or return self?
  126.  
  127.     tempStr = [MiscString newWithString:aString];
  128.     for (i=length-1;i>=0;i--)
  129.         if ([tempStr spotOf:buffer[i] caseSensitive:sense] != -1)
  130.             buffer[i] = replaceChar;
  131.  
  132.     [tempStr free];
  133.     return self;
  134. }
  135.  
  136. - replaceEveryOccurrenceOfChars:(const char *)aString withString:(id)sender
  137. {
  138.     if (![sender respondsTo:@selector(stringValue)]) return self;
  139.     return [self replaceEveryOccurrenceOfChars:aString
  140.             with:[sender stringValue] caseSensitive:YES];
  141. }
  142.  
  143. - replaceEveryOccurrenceOfChars:(const char *)aString
  144.         withString:(id)sender caseSensitive:(BOOL)sense
  145. {
  146.     if (![sender respondsTo:@selector(stringValue)]) return self;
  147.     return [self replaceEveryOccurrenceOfChars:aString
  148.             with:[sender stringValue] caseSensitive:sense];
  149. }
  150.  
  151. - replaceEveryOccurrenceOfChar:(char)aChar with:(const char *)aString
  152.         caseSensitive:(BOOL)sense
  153. {
  154.     int i;
  155.  
  156.     if (!aChar) return self; // I think a null string should be allowed here...
  157.     if (sense) {
  158.         for (i=length-1;i>=0;i--)
  159.             if (buffer[i] == aChar)
  160.                 [self replaceFrom:i to:i with:aString];
  161.     } else {
  162.         for (i=length-1;i>=0;i--)
  163.             if (NXToUpper(buffer[i]) == NXToUpper(aChar))
  164.                 [self replaceFrom:i to:i with:aString];
  165.     }
  166.     return self;
  167. }
  168.  
  169. - replaceEveryOccurrenceOfChar:(char)aChar with:(const char *)aString
  170. {
  171.     return [self replaceEveryOccurrenceOfChar:aChar
  172.             with:aString caseSensitive:YES];
  173. }
  174.  
  175. - replaceEveryOccurrenceOfChar:(char)aChar withString:(id)sender
  176. {
  177.     if (![sender respondsTo:@selector(stringValue)]) return self;
  178.     return [self replaceEveryOccurrenceOfChar:aChar
  179.             with:[sender stringValue] caseSensitive:YES];
  180. }
  181.  
  182. - replaceEveryOccurrenceOfChar:(char)aChar withString:(id)sender
  183.         caseSensitive:(BOOL)sense
  184. {
  185.     if (![sender respondsTo:@selector(stringValue)]) return self;
  186.     return [self replaceEveryOccurrenceOfChar:aChar
  187.             with:[sender stringValue] caseSensitive:sense];
  188. }
  189.  
  190. - replaceEveryOccurrenceOfChar:(char)aChar withChar:(char)replaceChar
  191.         caseSensitive:(BOOL)sense
  192. {
  193.     int i;
  194.  
  195.     if (!aChar) return self;
  196.     if (!replaceChar) return nil;  //or return self?
  197.  
  198.     if (sense) {
  199.         for (i=length-1; i>=0; i--)
  200.             if (buffer[i] == aChar)
  201.                 buffer[i] = replaceChar;
  202.     } else {
  203.         for (i=length-1; i>=0; i--)
  204.             if (NXToUpper(buffer[i]) == NXToUpper(aChar))
  205.                 buffer[i] = replaceChar;
  206.     }
  207.     return self;
  208. }
  209.  
  210.  
  211. - replaceEveryOccurrenceOfChar:(char)aChar withChar:(char)replaceChar
  212. {
  213.     return [self replaceEveryOccurrenceOfChar:aChar
  214.             withChar:replaceChar caseSensitive:YES];
  215. }
  216.  
  217. // string replacements by Bruce McKenzie <bruce@trwlasd.com>
  218. - replaceEveryOccurrenceOf:(const char *)subString    
  219.     with:(const char *)newString
  220. {
  221.     const char *spot;
  222.     int subStringLen;
  223.     
  224.     if (!subString) return nil;
  225.     subStringLen = strlen(subString);
  226.     if (!subStringLen) return nil;
  227.     while ((spot = [self strstr:subString]))
  228.         [self replaceFrom:(int)(spot-buffer) length:subStringLen
  229.                 with:(newString ? newString : "")];
  230.     return self;
  231. }
  232.  
  233. // and three extra covers by Don Yacktman:
  234. - replaceEveryOccurrenceOfString:(id)subString with:(const char *)newString
  235. {
  236.     return [self replaceEveryOccurrenceOf:[subString stringValue]
  237.                 with:newString];
  238. }
  239.  
  240. - replaceEveryOccurrenceOf:(const char *)subString withString:(id)newString
  241. {
  242.     return [self replaceEveryOccurrenceOf:subString
  243.                 with:[newString stringValue]];
  244. }
  245.  
  246. - replaceEveryOccurrenceOfString:(id)subString withString:(id)newString
  247. {
  248.     return [self replaceEveryOccurrenceOf:[subString stringValue]
  249.                 with:[newString stringValue]];
  250. }
  251.  
  252. @end
  253.