home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1 / Nebula One.iso / Mail / MailEnclosure / Source.v0.15 / StringStorage.m < prev    next >
Encoding:
Text File  |  1995-06-12  |  2.9 KB  |  159 lines
  1. /*
  2. ** StringStorage.m,v 1.5 1992/09/24 03:34:31 nwc Exp
  3. **
  4. ** Copyright (c) 1991 Ronin Consulting, Inc.
  5. */
  6.  
  7.  
  8. #import "StringStorage.h"
  9. #import "limits.h"
  10. #import <string.h>
  11.  
  12. static char EOS = (char)0;
  13.  
  14. @implementation StringStorage
  15.  
  16. - init
  17. {
  18.    [self init: ""];
  19.    return self;
  20. }
  21.  
  22. - init: (const char *) str
  23. {
  24.    [super init];
  25.    
  26.    [self initCount: 0 elementSize: sizeof(char) description: "c"];
  27.    [self setStringValue: str];
  28.    return self;
  29. }
  30.  
  31. - setStringValue: (const char *) str;
  32. {
  33.    int len;
  34.  
  35.    if(!str)
  36.        str = "";                 /* avoid nil strings */
  37.  
  38.    len = strlen(str);                 /* get length - no reason to do it twice */
  39.    [self setNumSlots: len + 1];             /* use setNumSlots vs setAvailCapacity since it sets count */
  40.  
  41.                          /* bcopy is far faster than strcpy if the length is known */
  42.    bcopy(str, (char *)dataPtr, len); 
  43.    [self replaceElementAt: len with: (char *)&EOS];
  44.    return self;
  45. }
  46.  
  47. - (const char *) stringValue
  48. {
  49.    return dataPtr;
  50. }
  51.  
  52. - appendStringValue: (const char *)str
  53. {
  54.    int oldCount = [self count];
  55.    int len;
  56.  
  57.    if(!str || !*str)                 /* nothing to append */
  58.        return self;
  59.    
  60.    len = strlen(str);                 
  61.    [self setNumSlots: oldCount + len];
  62.    bcopy(str, (char *)[self elementAt: oldCount - 1], len);
  63.    [self replaceElementAt: oldCount + len - 1 with: (char *)&EOS ];
  64.    return self;
  65. }
  66.  
  67. - appendCharValue: (char) c
  68. {
  69.    char buf[2];
  70.    
  71.    buf[0] = c;
  72.    buf[1] = (char)0;
  73.  
  74.    [self appendStringValue: buf];
  75.  
  76.    return self;
  77. }
  78.  
  79. - empty                         /* override to ensure null termination */
  80. {
  81.    [super empty];
  82.    [self setStringValue: ""];
  83.    return self;
  84. }
  85.  
  86. - (int) strlen                     /* just (count - 1)...but nicer */
  87. {
  88.    return [self count] - 1;
  89. }
  90.  
  91. - (int) matchSubstring: (const char *)str
  92. {
  93.    int x, cnt;
  94.  
  95.    if(!str)
  96.        return -1;
  97.  
  98.    for (x = 0, cnt = [self strlen]; x <  cnt; x++)
  99.        if(((char *)dataPtr)[x] == *str && !strncmp(str,(char *)dataPtr + x, strlen(str)))
  100.        return x;
  101.  
  102.    return -1;
  103. }
  104.  
  105. - (char *) getSubstring: (const char *)str
  106. {
  107.    int offset;
  108.  
  109.    offset = [self matchSubstring: str];
  110.    if(offset != -1)
  111.        return dataPtr + offset;
  112.    else
  113.        return (char*)0;
  114. }
  115.  
  116. - replaceSubstring: (const char *)str with: (const char *)str2
  117. {
  118.    int offset, len1, len2;
  119.  
  120.    if(!(str && str2))
  121.        return nil;
  122.  
  123.    offset = [self matchSubstring: str];
  124.    if(offset == -1)
  125.        return nil;
  126.  
  127.    len1 = strlen(str);
  128.    len2 = strlen(str2);
  129.  
  130.    if(len2 > len1)
  131.        [self setNumSlots: [self count] + len2 - len1];
  132.  
  133.    bcopy((char *)dataPtr + offset + len1, (char *)dataPtr + offset + len2, 
  134.      [self count] - offset - len1);
  135.  
  136.    bcopy((char *)str2, (char *)dataPtr + offset, len2);
  137.    
  138.    if(len2 < len1)
  139.    {
  140.       [self setNumSlots: [self count] + len2 - len1];
  141.       ((char *)dataPtr)[[self strlen]] = (char)0;
  142.    }
  143.    
  144.    return self;
  145. }
  146.  
  147. - (unsigned int)hash
  148. {
  149.    unsigned int x = 0;
  150.    int y, cnt;
  151.  
  152.    for(y = 0, cnt = [self strlen]; y < cnt; y++)
  153.        x += ((char *)(dataPtr))[y];
  154.  
  155.    return x;
  156. }
  157.  
  158. @end
  159.