Mostly skeletal implementation of NSIndexSet

git-svn-id: svn+ssh://svn.gna.org/svn/gnustep/libs/base/trunk@18650 72102866-910b-0410-8b05-ffd578937521

ChangeLog

@@ -10,6 +10,12 @@
 	c-strings without nul terminators using '%*.*s' format.
 	* Source/Additions/GSMime.m: Fix cases of possible access beyond buffer
 	and rare overflow writing decoded base64 data.
+	* Headers/Foundation/NSKeyedArchiver.h: Remove stuff saying this is
+	not implemented ... it is now.
+	* Source/NSIndexSet.m: Partial implementation untested ... at least
+	it's a skeleton for people to work on ... committed now because I'm
+	away for a few weeks on holiday.
+	* Headers/Foundation/NSIndexSet.h: Partial documentation.
 
 2004-02-23  Adam Fedor  <fedor@gnu.org>
 

Headers/Foundation/NSIndexSet.h

@@ -0,0 +1,176 @@
+/** Interface for NSIndexSet, NSMutableIndexSet for GNUStep
+   Copyright (C) 2004 Free Software Foundation, Inc.
+
+   Written by:  Richard Frith-Macdonald <rfm@gnu.org>
+   Created: Feb 2004
+   
+   This file is part of the GNUstep Base Library.
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+   
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+   
+   You should have received a copy of the GNU Library General Public
+   License along with this library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA.
+
+   AutogsdocSource: NSIndexSet.m
+
+   */ 
+
+#ifndef _NSIndexSet_h_GNUSTEP_BASE_INCLUDE
+#define _NSIndexSet_h_GNUSTEP_BASE_INCLUDE
+
+#ifndef	STRICT_OPENSTEP
+
+#include	<Foundation/NSObject.h>
+#include	<Foundation/NSRange.h>
+
+/**
+ * <strong> NOT YET IMPLEMENTED/TESTED </strong>
+ * Instances of this class are collections of unsigned integers in the
+ * range 0 to NSNotFound-1.<br />
+ * Each integer can appear in a collection only once.
+ */
+@interface	NSIndexSet : NSObject <NSCopying, NSMutableCopying, NSCoding>
+{
+  void	*_data;
+}
+
+/**
+ * Return an empty set.
+ */
++ (id) indexSet;
+
+/**
+ * Return a set containing the single value anIndex, or returns nil if
+ * anIndex is NSNotFound.
+ */
++ (id) indexSetWithIndex: (unsigned int)anIndex;
+
+/**
+ * Return a set containing all the values in aRange, or returns nil if
+ * aRange contains NSNotFound.
+ */
++ (id) indexSetWithIndexesInRange: (NSRange)aRange;
+
+/**
+ * Returns YES if the receiver contains anIndex, NO otherwise.
+ */
+- (BOOL) containsIndex: (unsigned int)anIndex;
+
+/**
+ * Returns YES if the receiver contains all the index values present
+ * in aSet, NO otherwise.
+ */
+- (BOOL) containsIndexes: (NSIndexSet*)aSet;
+
+/**
+ * Returns YES if the receiver contains all the index values present
+ * in aRange, NO otherwise.
+ */
+- (BOOL) containsIndexesInRange: (NSRange)aRange;
+
+/**
+ * Returns the number of index values present in the receiver.
+ */
+- (unsigned int) count;
+
+/**
+ * Returns the first index value in the receiver or NSNotFound if the
+ * receiver is empty.
+ */
+- (unsigned int) firstIndex;
+
+/**
+ * Copies index values into aBuffer until there are no index values left or
+ * aBuffer is full (assuming that the size of aBuffer is given by aCount).<br />
+ * Only copies index values present in aRange and copies them in order.<br />
+ * Returns the number of index values placed in aVuffer.<br />
+ * Modifies aRange to start after the last index value copied.<br />
+ */
+- (unsigned int) getIndexes: (unsigned int*)aBuffer
+		   maxCount: (unsigned int)aCount
+	       inIndexRange: (NSRangePointer)aRange;
+
+/**
+ * Return the first index value in the receiver which is greater than
+ * anIndex.
+ */
+- (unsigned int) indexGreaterThanIndex: (unsigned int)anIndex;
+
+/**
+ * Return the first index value in the receiver which is greater than
+ * or equal to anIndex.
+ */
+- (unsigned int) indexGreaterThanOrEqualToIndex: (unsigned int)anIndex;
+
+/**
+ * Return the first index value in the receiver which is less than
+ * anIndex.
+ */
+- (unsigned int) indexLessThanIndex: (unsigned int)anIndex;
+
+/**
+ * Return the first index value in the receiver which is less than
+ * or equal to anIndex.
+ */
+- (unsigned int) indexLessThanOrEqualToIndex: (unsigned int)anIndex;
+
+/**
+ * Initialise the receiver to contain anIndex.  Returns the initialised
+ * object or nil if anIndex is NSNotFound.
+ */
+- (id) initWithIndex: (unsigned int)anIndex;
+
+/** <init />
+ * Initialise the receiver to contain all index values in aRange.
+ * Returns the initialised object or nil if aRange contains NSNotFound.
+ */
+- (id) initWithIndexesInRange: (NSRange)aRange;
+
+/**
+ * Initialises the receiver with the index values from aSet.
+ */
+- (id) initWithIndexSet: (NSIndexSet*)aSet;
+
+/**
+ * Returns YES if the receiver contains any index values which lie in aRange,
+ * No otherwise.
+ */
+- (BOOL) intersectsIndexesInRange: (NSRange)aRange;
+
+/**
+ * Tests two index sets for equality and returns either YES or NO.
+ */
+- (BOOL) isEqualToIndexSet: (NSIndexSet*)aSet;
+
+/**
+ * Returns the last index value in the receiver or NSNotFound if the
+ * receiver is empty.
+ */
+- (unsigned int) lastIndex;
+@end
+
+
+@interface	NSMutableIndexSet : NSIndexSet
+
+- (void) addIndex: (unsigned int)anIndex;
+- (void) addIndexes: (NSIndexSet*)aSet;
+- (void) addIndexesInRange: (NSRange)aRange;
+- (void) removeAllIndexes;
+- (void) removeIndex: (unsigned int)anIndex;
+- (void) removeIndexes: (NSIndexSet*)aSet;
+- (void) removeIndexesInRange: (NSRange)aRange;
+- (void) shiftIndexesStartingAtIndex: (unsigned int)anIndex by: (int)amount;   
+
+@end
+
+#endif
+#endif

Headers/Foundation/NSKeyedArchiver.h

@@ -37,7 +37,7 @@
 @class NSMutableDictionary, NSMutableData, NSData, NSString;
 
 /**
- * Keyed archiving class, <strong>NOT YET IMPLEMENTED</strong>
+ * Keyed archiving class
  */
 @interface NSKeyedArchiver : NSCoder
 {
@@ -101,7 +101,9 @@
 - (id) delegate;
 
 - (void) encodeBool: (BOOL)aBool forKey: (NSString*)aKey;
-- (void) encodeBytes: (const uint8_t*)aPointer length: (unsigned)length forKey: (NSString*)aKey;
+- (void) encodeBytes: (const uint8_t*)aPointer
+	      length: (unsigned)length
+	      forKey: (NSString*)aKey;
 - (void) encodeConditionalObject: (id)anObject forKey: (NSString*)aKey;
 - (void) encodeDouble: (double)aDouble forKey: (NSString*)aKey;
 - (void) encodeFloat: (float)aFloat forKey: (NSString*)aKey;
@@ -157,7 +159,7 @@
 
 
 /**
- * Keyed unarchiving class, <strong>NOT YET IMPLEMENTED</strong>
+ * Keyed unarchiving class.
  */
 @interface NSKeyedUnarchiver : NSCoder
 {

Source/GNUmakefile

@@ -173,6 +173,7 @@ NSFormatter.m \
 NSGeometry.m \
 NSHashTable.m \
 NSHost.m \
+NSIndexSet.m \
 NSInvocation.m \
 NSKeyedArchiver.m \
 NSKeyedUnarchiver.m \
@@ -289,6 +290,7 @@ NSFormatter.h \
 NSGeometry.h \
 NSHashTable.h \
 NSHost.h \
+NSIndexSet.h \
 NSInvocation.h \
 NSKeyedArchiver.h \
 NSKeyValueCoding.h \

Source/Makefile.preamble

@@ -78,7 +78,7 @@ ifeq ($(GNUSTEP_TARGET_OS),cygwin)
 libgnustep-base_LIBRARIES_DEPEND_UPON += -lobjc
 endif
 ifeq ($(shared),yes)
-libgnustep-base_LIBRARIES_DEPEND_UPON += $(CONFIG_SYSTEM_LIBS) 
+libgnustep-base_LIBRARIES_DEPEND_UPON += $(CONFIG_SYSTEM_LIBS)
 libgnustep-baseadd_LIBRARIES_DEPEND_UPON += $(CONFIG_SYSTEM_LIBS) 
 endif
 

Source/NSIndexSet.m

@@ -0,0 +1,540 @@
+/** Implementation for NSIndexSet, NSMutableIndexSet for GNUStep
+   Copyright (C) 2004 Free Software Foundation, Inc.
+
+   Written by:  Richard Frith-Macdonald <rfm@gnu.org>
+   Created: Feb 2004
+   
+   This file is part of the GNUstep Base Library.
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+   
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+   
+   You should have received a copy of the GNU Library General Public
+   License along with this library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA.
+
+   */ 
+
+#include	<Foundation/NSIndexSet.h>
+#include	<Foundation/NSException.h>
+#include	<Foundation/NSZone.h>
+
+#define	GSI_ARRAY_TYPE	NSRange
+#define GSI_ARRAY_TYPES	GSI_ARRAY_EXTRA
+
+#define	GSI_ARRAY_NO_RELEASE	1
+#define	GSI_ARRAY_NO_RETAIN	1
+
+#include "GNUstepBase/GSIArray.h"
+
+#define	_array	((GSIArray)(self->_data))
+
+/*
+ * Returns the position in the array at which the index should be inserted.
+ * This may be the position of a range containing the index if it is already
+ * present, otherwise it is the position of the first range containing an
+ * index greater than the argument (or a position beyond the end of the
+ * array).
+ */
+static unsigned posForIndex(GSIArray array, unsigned index)
+{
+  unsigned int	upper = GSIArrayCount(array);
+  unsigned int	lower = 0;
+  unsigned int	pos;
+
+  /*
+   *	Binary search for an item equal to the one to be inserted.
+   */
+  for (pos = upper/2; upper != lower; pos = (upper+lower)/2)
+    {
+      NSRange	r = GSIArrayItemAtIndex(array, pos).ext;
+
+      if (index < r.location)
+        {
+          upper = pos;
+        }
+      else if (index > NSMaxRange(r))
+        {
+          lower = pos + 1;
+        }
+      else
+        {
+          break;
+        }
+    }
+  /*
+   *	Now skip past any equal items so the insertion point is AFTER any
+   *	items that are equal to the new one.
+   */
+  while (pos < GSIArrayCount(array)
+    && index >= NSMaxRange(GSIArrayItemAtIndex(array, pos).ext))
+    {
+      pos++;
+    }
+  return pos;
+}
+
+@implementation	NSIndexSet
++ (id) indexSet
+{
+  id	o = [self allocWithZone: NSDefaultMallocZone()];
+
+  o = [o init];
+  return AUTORELEASE(o);
+}
+
++ (id) indexSetWithIndex: (unsigned int)anIndex;
+{
+  id	o = [self allocWithZone: NSDefaultMallocZone()];
+
+  o = [o initWithIndex: anIndex];
+  return AUTORELEASE(o);
+}
+
++ (id) indexSetWithIndexesInRange: (NSRange)aRange;
+{
+  id	o = [self allocWithZone: NSDefaultMallocZone()];
+
+  o = [o initWithIndexesInRange: aRange];
+  return AUTORELEASE(o);
+}
+
+- (BOOL) containsIndex: (unsigned int)anIndex
+{
+  unsigned	pos;
+
+  if (_array == 0 || GSIArrayCount(_array) == 0)
+    {
+      return NO;
+    }
+  pos = posForIndex(_array, anIndex);
+  if (pos >= GSIArrayCount(_array))
+    {
+      return NO;
+    }
+  return NSLocationInRange(anIndex, GSIArrayItemAtIndex(_array, pos).ext);
+}
+
+- (BOOL) containsIndexes: (NSIndexSet*)aSet
+{
+  if (_array == 0 || GSIArrayCount(_array) == 0)
+    {
+      return NO;
+    }
+  [self notImplemented:_cmd];
+  return NO;
+}
+
+- (BOOL) containsIndexesInRange: (NSRange)aRange
+{
+  unsigned	pos;
+
+  if (_array == 0 || GSIArrayCount(_array) == 0)
+    {
+      return NO;	// Empty ... contains no indexes.
+    }
+  if (aRange.length == 0)
+    {
+      return YES;	// No indexes needed.
+    }
+  pos = posForIndex(_array, aRange.location);
+  if (pos >= GSIArrayCount(_array))
+    {
+      return NO;
+    }
+  if (NSLocationInRange(aRange.location, GSIArrayItemAtIndex(_array, pos).ext)
+    && NSLocationInRange(NSMaxRange(aRange)-1, GSIArrayItemAtIndex(_array, pos).ext))
+    {
+      return YES;
+    }
+  return NO;
+}
+
+- (id) copyWithZone: (NSZone*)aZone
+{
+  if (NSShouldRetainWithZone(self, aZone))
+    {
+      return RETAIN(self);
+    }
+  else
+    {
+      NSIndexSet	*c = [NSIndexSet allocWithZone: aZone];
+
+      return [c initWithIndexSet: self];
+    }
+}
+
+- (unsigned int) count
+{
+  if (_array == 0 || GSIArrayCount(_array) == 0)
+    {
+      return 0;
+    }
+  else
+    {
+      unsigned	count = GSIArrayCount(_array);
+      unsigned	total = 0;
+      unsigned	i = 0;
+
+      while (i < count)
+	{
+	  total += GSIArrayItemAtIndex(_array, i).ext.length;
+	}
+      return total;
+    }
+}
+
+- (void) dealloc
+{
+  if (_array != 0)
+    {
+      GSIArrayClear(_array);
+      NSZoneFree([self zone], _array);
+      _array = 0;
+    }
+  [super dealloc];
+}
+
+- (void) encodeWithCoder: (NSCoder*)aCoder
+{
+  [self notImplemented:_cmd]; 
+}
+
+- (unsigned int) firstIndex
+{
+  if (_array == 0 || GSIArrayCount(_array) == 0)
+    {
+      return NSNotFound;
+    }
+  return GSIArrayItemAtIndex(_array, 0).ext.location;
+}
+
+- (unsigned int) getIndexes: (unsigned int*)aBuffer
+		   maxCount: (unsigned int)aCount
+	       inIndexRange: (NSRangePointer)aRange
+{
+  unsigned	pos;
+  unsigned	i = 0;
+  NSRange	r;
+
+  if (_array == 0 || GSIArrayCount(_array) == 0
+    || (pos = posForIndex(_array, aRange->location)) >= GSIArrayCount(_array))
+    {
+      *aRange = NSMakeRange(NSMaxRange(*aRange), 0);
+      return 0;
+    }
+
+  while (aRange->length > 0 && i < aCount && pos < GSIArrayCount(_array))
+    {
+      r = GSIArrayItemAtIndex(_array, pos).ext;
+      if (aRange->location < r.location)
+	{
+	  unsigned	skip = r.location - aRange->location;
+
+	  if (skip > aRange->length)
+	    {
+	      skip = aRange->length;
+	    }
+	  aRange->location += skip;
+	  aRange->length -= skip;
+	}
+      else if (NSLocationInRange(aRange->location, r))
+	{
+	  while (aRange->length > 0 && i < aCount
+	    && aRange->location < NSMaxRange(r))
+	    {
+	      aBuffer[i++] = aRange->location++;
+	      aRange->length--;
+	    }
+	}
+      else
+	{
+	}
+      pos++;
+    }
+  return i;
+}
+
+- (unsigned int) hash
+{
+  return [self count];
+}
+
+- (unsigned int) indexGreaterThanIndex: (unsigned int)anIndex
+{
+  unsigned	pos;
+
+  if (_array == 0 || GSIArrayCount(_array) == 0)
+    {
+      return NSNotFound;
+    }
+  pos = posForIndex(_array, anIndex + 1);
+  if (pos >= GSIArrayCount(_array))
+    {
+      return NSNotFound;
+    }
+  if (NSLocationInRange(anIndex + 1, GSIArrayItemAtIndex(_array, pos).ext))
+    {
+      return anIndex + 1;
+    }
+  return GSIArrayItemAtIndex(_array, pos+1).ext.location;
+}
+
+- (unsigned int) indexGreaterThanOrEqualToIndex: (unsigned int)anIndex
+{
+  unsigned	pos;
+
+  if (_array == 0 || GSIArrayCount(_array) == 0)
+    {
+      return NSNotFound;
+    }
+  pos = posForIndex(_array, anIndex);
+  if (pos >= GSIArrayCount(_array))
+    {
+      return NSNotFound;
+    }
+  if (NSLocationInRange(anIndex, GSIArrayItemAtIndex(_array, pos).ext))
+    {
+      return anIndex;
+    }
+  return GSIArrayItemAtIndex(_array, pos+1).ext.location;
+}
+
+- (unsigned int) indexLessThanIndex: (unsigned int)anIndex
+{
+  unsigned	pos;
+
+  if (anIndex == 0)
+    {
+      return NSNotFound;
+    }
+  if (_array == 0 || GSIArrayCount(_array) == 0)
+    {
+      return NSNotFound;
+    }
+  pos = posForIndex(_array, anIndex - 1);
+  if (pos >= GSIArrayCount(_array))
+    {
+      return NSNotFound;
+    }
+  if (NSLocationInRange(anIndex - 1, GSIArrayItemAtIndex(_array, pos).ext))
+    {
+      return anIndex - 1;
+    }
+  if (pos == 0)
+    {
+      return NSNotFound;
+    }
+  return NSMaxRange(GSIArrayItemAtIndex(_array, pos).ext) - 1;
+}
+
+- (unsigned int) indexLessThanOrEqualToIndex: (unsigned int)anIndex
+{
+  unsigned	pos;
+
+  if (_array == 0 || GSIArrayCount(_array) == 0)
+    {
+      return NSNotFound;
+    }
+  pos = posForIndex(_array, anIndex);
+  if (pos >= GSIArrayCount(_array))
+    {
+      return NSNotFound;
+    }
+  if (NSLocationInRange(anIndex, GSIArrayItemAtIndex(_array, pos).ext))
+    {
+      return anIndex;
+    }
+  if (pos == 0)
+    {
+      return NSNotFound;
+    }
+  return NSMaxRange(GSIArrayItemAtIndex(_array, pos).ext) - 1;
+}
+
+- (id) init
+{
+  return self;
+}
+
+- (id) initWithCoder: (NSCoder*)aCoder
+{
+  [self notImplemented:_cmd]; 
+  return self;
+}
+
+- (id) initWithIndex: (unsigned int)anIndex
+{
+  if (anIndex == NSNotFound)
+    {
+      DESTROY(self);	// NSNotFound is not legal
+    }
+  else
+    {
+      self = [self initWithIndexesInRange: NSMakeRange(anIndex, 1)];
+    }
+  return self;
+}
+
+- (id) initWithIndexesInRange: (NSRange)aRange
+{
+  if (aRange.length > 0)
+    {
+      if (NSMaxRange(aRange) == NSNotFound)
+	{
+	  DESTROY(self);	// NSNotFound is not legal
+	}
+      else
+	{
+	  _array = (GSIArray)NSZoneMalloc([self zone], sizeof(GSIArray_t));
+	  GSIArrayInitWithZoneAndCapacity(_array, [self zone], 1);
+	  GSIArrayAddItem(_array, (GSIArrayItem)aRange);
+	}
+    }
+  return self;
+}
+
+- (id) initWithIndexSet: (NSIndexSet*)aSet
+{
+  [self notImplemented:_cmd]; 
+  return self;
+}
+
+- (BOOL) intersectsIndexesInRange: (NSRange)aRange
+{
+  unsigned	p1;
+  unsigned	p2;
+
+  if (aRange.length == 0 || _array == 0 || GSIArrayCount(_array) == 0)
+    {
+      return NO;	// Empty
+    }
+  p1 = posForIndex(_array, aRange.location);
+  p2 = posForIndex(_array, NSMaxRange(aRange) - 1);
+  if (p1 != p2)
+    {
+      return YES;
+    }
+  if (p1 >= GSIArrayCount(_array))
+    {
+      return NO;
+    }
+  if (NSLocationInRange(aRange.location, GSIArrayItemAtIndex(_array, p1).ext))
+    {
+      return YES;
+    }
+  if (NSLocationInRange(NSMaxRange(aRange)-1,
+      GSIArrayItemAtIndex(_array, p1).ext))
+    {
+      return YES;
+    }
+  return NO;
+}
+
+- (BOOL) isEqual: (id)aSet
+{
+  if ([aSet isKindOfClass: [NSIndexSet class]] == YES)
+    {
+      return [self isEqualToIndexSet: aSet];
+    }
+  return NO;
+}
+
+- (BOOL) isEqualToIndexSet: (NSIndexSet*)aSet
+{
+  [self notImplemented:_cmd];
+  return NO;
+}
+
+- (unsigned int) lastIndex
+{
+  if (_array == 0 || GSIArrayCount(_array) == 0)
+    {
+      return NSNotFound;
+    }
+  return GSIArrayItemAtIndex(_array, GSIArrayCount(_array)-1).ext.location;
+}
+
+- (id) mutableCopyWithZone: (NSZone*)aZone
+{
+  NSMutableIndexSet	*c = [NSMutableIndexSet allocWithZone: aZone];
+
+  return [c initWithIndexSet: self];
+}
+
+@end
+
+
+@implementation	NSMutableIndexSet
+
+- (void) addIndex: (unsigned int)anIndex
+{
+  [self addIndexesInRange: NSMakeRange(anIndex, 1)];
+}
+
+- (void) addIndexes: (NSIndexSet*)aSet
+{
+  [self notImplemented:_cmd];
+} 
+
+- (void) addIndexesInRange: (NSRange)aRange
+{
+  if (_array == 0)
+    {
+      _array = (GSIArray)NSZoneMalloc([self zone], sizeof(GSIArray_t));
+      GSIArrayInitWithZoneAndCapacity(_array, [self zone], 1);
+    }
+  if (GSIArrayCount(_array) == 0)
+    {
+      GSIArrayAddItem(_array, (GSIArrayItem)aRange);
+    }
+  else
+    {
+      [self notImplemented:_cmd];
+    }
+}
+
+- (id) copyWithZone: (NSZone*)aZone
+{
+  NSIndexSet	*c = [NSIndexSet allocWithZone: aZone];
+
+  return [c initWithIndexSet: self];
+}
+
+- (void) removeAllIndexes
+{
+  if (_array != 0)
+    {
+      GSIArrayRemoveAllItems(_array);
+    }
+}
+
+- (void) removeIndex: (unsigned int)anIndex
+{
+  [self notImplemented:_cmd];
+}
+
+- (void) removeIndexes: (NSIndexSet*)aSet
+{
+  [self notImplemented:_cmd];
+}
+
+- (void) removeIndexesInRange: (NSRange)aRange
+{
+  [self notImplemented:_cmd];
+}
+
+- (void) shiftIndexesStartingAtIndex: (unsigned int)anIndex by: (int)amount
+{
+  [self notImplemented:_cmd];
+} 
+
+@end
+