ftp.nice.ch/pub/next/games/network/NeXTGo.2.7.NIHS.bs.gnutar.gz#/NeXTGo/MiscStringModification.m

This is MiscStringModification.m in view mode; [Download] [Up]

//
//	MiscStringModification.m
//		Written by Don Yacktman Copyright (c) 1993 by Don Yacktman.
//				Version 1.95  All rights reserved.
//		This notice may not be removed from this source code.
//
//	This object is included in the MiscKit by permission from the author
//	and its use is governed by the MiscKit license, found in the file
//	"LICENSE.rtf" in the MiscKit distribution.  Please refer to that file
//	for a list of all applicable permissions and restrictions.
//	

#import <misckit/MiscString.h>

@implementation MiscString(Modification)

// This category is composed of methods which modify a MiscString in
// various ways (case conversion, trimming whitespace, deleting portions
// of the string, and so on).

- setStringValue:(const char *)aString
{
	return [self setStringValue:aString fromZone:[self zone]];
}

- setStringValue:(const char *)aString fromZone:(NXZone *)zone
{
	if (!aString) return self; // use -freeString to set to "NULL"
	// Note that I could have used NXCopyStringBufferFromZone() here
	// instead.  This works just as well, but it may be slower...
	// I haven't checked that out, though.  It might be worth doing.
	[self allocateBuffer:(strlen(aString)+1) fromZone:zone];
	strcpy(buffer, aString);
	length = strlen(buffer);
	return self;
}

- setStringValue:(const char *)aString n:(int)n
{
	return [self setStringValue:aString n:n fromZone:[self zone]];
}

- setStringValue:(const char *)aString n:(int)n fromZone:(NXZone *)zone
{
	char *buf = NULL;
	if ((aString) && (n > 0))  {
		NX_MALLOC(buf, char, n + 1);
		strncpy(buf, aString, n);
		buf[n]='\0';
	}
	[self setStringValue:buf fromZone:zone];
	NX_FREE(buf);
	return self;
}

- setFromFormat:(const char *)formatStr, ...
// Sets the string from and printf style format string and arguments.
{
	va_list param_list;
	char *buf;

	va_start(param_list, formatStr);
	buf = MiscBuildStringFromFormatV(formatStr, param_list);
	va_end(param_list);
	[self setStringValue:buf];
	NX_FREE(buf);
	return self;
}

- setIntValue:(int)val
// Sets the string by converting the given int to a string.
{
	return [self setFromFormat:"%d", val];
}

- setFloatValue:(float)val
// Sets the string by converting the given float to a string.
{
	return [self setFromFormat:"%f", val];
}

- setDoubleValue:(double)val
// Sets the string by converting the given double to a string.
{
	return [self setFromFormat:"%f", val];
}

- sprintf:(const char *)formatStr, ...
// Sets the strings contents as the result of printf'ing with the
// given format string and arguments.  Same as setFromFormat:, ...
{
	va_list param_list;
	char *buf;
	
	va_start(param_list, formatStr);
	buf = MiscBuildStringFromFormatV(formatStr, param_list);
	va_end(param_list);
	[self setStringValue:buf];
	NX_FREE(buf);
	return self;
}

- takeStringValueFrom:sender
{ // if no string value, return nil; the user is expecting a changed string
	if (!sender) return [self setStringValue:""]; // this seems reasonable...
		// but maybe I should just return nil instead...
	if (![sender respondsTo:@selector(stringValue)]) return nil;
	return [self setStringValue:[sender stringValue] fromZone:[self zone]];
}

- takeStringValueFrom:sender fromZone:(NXZone *)zone
{
	if (![sender respondsTo:@selector(stringValue)]) return nil;
	return [self setStringValue:[sender stringValue] fromZone:zone];
}

- takeIntValueFrom:sender
{
	if (![sender respondsTo:@selector(intValue)]) return nil;
	[self setIntValue:[sender intValue]];
	return self;
}

- takeFloatValueFrom:sender
{
	if (![sender respondsTo:@selector(floatValue)]) return nil;
	[self setFloatValue:[sender floatValue]];
	return self;
}

- takeDoubleValueFrom:sender
{
	if (![sender respondsTo:@selector(doubleValue)]) return nil;
	[self setDoubleValue:[sender doubleValue]];
	return self;
}

- trimLeadSpaces
{	// removes any leading spaces from buffer
	int i = 0;
	id tmpStr;

	if (!buffer) return self;
	if (length < 1) return self;
	while ((i < length) && (buffer[i] == ' ')) i++;
	if (i==0) return self;
	tmpStr = [self right:length-i];
	[self takeStringValueFrom:tmpStr];
	[tmpStr free];
	return self;
}

- trimTailSpaces
// removes any trailing spaces from buffer
{
	int i = length;
	id tmpStr;

	if (!buffer) return self;
	if (i < 1) return self;
	while ((i > 0) && (buffer[i-1] == ' ')) i--;
	if (i==length) return self;
	tmpStr = [self left:i];
	[self takeStringValueFrom:tmpStr];
	[tmpStr free];
	return self;
}

- trimSpaces
// takes off leading and trailing spaces of the buffer
{
	return [[self trimLeadSpaces] trimTailSpaces];
}

- trimLeadWhiteSpaces
// removes any leading white space from buffer
{ 
	int i = 0;
	id tmpStr;
	
	if (!buffer) return self;
	if (length < 1) return self;
	while ((i < length) && NXIsSpace(buffer[i])) i++;
	if (i==0) return self;
	tmpStr = [self right:length-i];
	[self takeStringValueFrom:tmpStr];
	[tmpStr free];
	return self;
}

- trimTailWhiteSpaces
// removes any leading white space from buffer
{ 
	int i = length;
	id tmpStr;
	
	if (!buffer) return self;
	if (i < 1) return self;
	while ((i > 0) && NXIsSpace(buffer[i-1])) i--;
	if (i==length) return self;
	tmpStr = [self left:i];
	[self takeStringValueFrom:tmpStr];
	[tmpStr free];
	return self;
}

- trimWhiteSpaces
// takes off leading and trailing spaces of the buffer
{
	return [[self trimLeadWhiteSpaces] trimTailWhiteSpaces];
}

- squashSpaces
{
  int count = 0;
  id tempStr;
  
  if (!buffer) return self;
  [self trimSpaces];
  tempStr = [[[[self class] alloc] init] allocateBuffer:length];
  while (count<length) {
    while ((count<length) && (buffer[count]!=' ')) {
      [tempStr addChar:buffer[count]];
      count++;
     }
    if ((count<length) && (buffer[count] == ' ')) {
      [tempStr addChar:buffer[count]];
      count++;
     }
    if ((count<length) && (buffer[count]==' ') && 
       ((buffer[count-2] == ':') || (buffer[count-2] =='.'))) {
         [tempStr addChar:buffer[count]];
         count++;
     }
    while (buffer[count]==' ') count++;
   }
  [self takeStringValueFrom:tempStr];
  [tempStr free];
  return self;
}

- reverse
// reverses the characters in the buffer.  If it's a palindrome, you won't
// notice much of a difference :-)
{
	char tmp[length+1];
	int i, j=0;
  
	if (length <= 1) return self;
	for (i=length-1; i>=0; i--) {
		tmp[j] = buffer[i];
		j++;
	}
	tmp[length] = 0;
	if (length != 0) [self setStringValue:tmp];
	return self;
}

- toUpper
// converts any lowercase characters in buffer to uppercase
{
	int i;
	for (i=0; i<length; i++) {
		if (NXIsLower(buffer[i])) buffer[i] = NXToUpper(buffer[i]);
	}
	return self;
}

- toLower
// converts any uppercase chars in buffer to lowercase
{
	int i;
	for (i=0; i<length; i++) {
		if (NXIsUpper(buffer[i])) buffer[i] = NXToLower(buffer[i]);
	}
	return self;
}

- invertCases
{
	int i;
	for (i=0; i<length; i++) {
		if (NXIsUpper(buffer[i])) buffer[i] = NXToLower(buffer[i]);
		else buffer[i] = NXToUpper(buffer[i]);
	}
	return self;
}

- capitalizeEachWord
{ // ***** it might be nice to NOT capitalize words like "a" "an" and "the"
	// so that capitalizations follw the style of titles, etc.
	int i = 0;
	if (!buffer) return 0;  
	while (i <= length) {
		while ((NXIsSpace(buffer[i])) && (i <= length)) i++;
		if (i < length) buffer[i] = NXToUpper(buffer[i]);
		while ((!NXIsSpace(buffer[i])) && (i <= length)) i++;
	}
	return self;
}

- removeFrom:(int)index length:(int)len
{ // to avoid memory leaks, this should NEVER return nil!
  id temp1,temp2;
  
  if (!buffer) return self;	// everything's already gone
  if (len <= 0) return self; // noting to remove
  // DAY: should I presume to fix index<0 like so? or just index = 0?
  // or just return self?
  if (index < 0) { len += index; index = 0; if (len <= 0) return self; }
  if (index > length - 1) return self; // nothing out there
  temp1 = [self left:index];
  if (!temp1) temp1 = [[[self class] alloc] init];
  temp2 = [self midFrom:index+len to:length];
  [temp1 concatenate:temp2];
  [self takeStringValueFrom:temp1];
  [temp1 free];
  [temp2 free];
  return self;
}

- removeFrom:(int)start to:(int)end
{
  return [self removeFrom:start length:end-start+1];
}

- (int)gets
{
  char c;
  [self setStringValue:""];
  
  while (((c = getchar()) != '\n') && (c != EOF)) {
    if (length == _length-1) [self setCapacity:length*2];
    [self addChar:c];
   }
  return (c == '\n')? 0:EOF;
}

- (int)fgets:(FILE *)fd keepNewline:(BOOL)keepit
{
  char c;
  [self setStringValue:""];
  
  while (((c = fgetc(fd)) != '\n') && (c != EOF)) {
    if (length == _length-1) [self setCapacity:length*2];
    [self addChar:c];
   }
  if (keepit && (c == '\n')) [self addChar:'\n']; //don't add EOF
  return (c == '\n')? 0:EOF;
}

- (int)fgets:(FILE *)fd
{
  return [self fgets:fd keepNewline:YES];
}

 
- (int)streamGets:(NXStream *)stream keepNewline:(BOOL)keepit
{
  char c = '\0';
  [self setStringValue:""];
  
  while (!NXAtEOS(stream) && ((c = NXGetc(stream)) != '\n') && (c != EOF)) {
    if (length == _length-1) [self setCapacity:length*2];
    [self addChar:c];
   }
  if (keepit && (c == '\n')) [self addChar:'\n']; //don't add EOF
  return (c == '\n')? 0:EOF;
}

- (int)streamGets:(NXStream *)stream
{
  return [self streamGets:stream keepNewline:YES];
}

- padToLength:(int)len withChar:(char)aChar
{
  int i;
  
  for (i=length;i<len;i++) {
    if (length == _length-1) [self setCapacity:length*2];
    [self addChar:aChar];
   }
  return self;
}

- padFrontToLength:(int)len withChar:(char)aChar
{
  if (len > length) {
    id string = [[[[self class] alloc] initCapacity:len-length+1]
                    padToLength:len-length withChar:aChar];
    [self insertString:string];
    [string free];
  }
  
  return self;
}

// need a removePart:... series like the extract part stuff.
@end

These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Marcel Waldvogel and Netfuture.ch.