ObjFW  Diff

/*
 * Copyright (c) 2008 - 2009
 *   Jonathan Schleifer <js@webkeks.org>
 *
 * All rights reserved.
 *
 * This file is part of libobjfw. It may be distributed under the terms of the
 * Q Public License 1.0, which can be found in the file LICENSE included in
 * the packaging of this file.
 */

#import "config.h"

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>

#import "OFArray.h"
#import "OFExceptions.h"
#import "OFMacros.h"

static size_t lastpagebyte = 0;
extern int getpagesize(void);

@implementation OFArray
+ arrayWithItemSize: (size_t)is
+ array
{
	return [[[OFArray alloc] initWithItemSize: is] autorelease];
	return [[[OFArray alloc] init] autorelease];
}

+ bigArrayWithItemSize: (size_t)is
{
	return [[[OFBigArray alloc] initWithItemSize: is] autorelease];
}

- initWithItemSize: (size_t)is
- init
{
	Class c;

	self = [super init];

	if (is == 0) {
		c = isa;
		[super free];
		@throw [OFInvalidArgumentException newWithClass: c];
	}

	data = NULL;
	itemsize = is;

	@try {
		array = [[OFDataArray alloc]
		    initWithItemSize: sizeof(OFObject*)];
	items = 0;

	} @catch (OFException *e) {
	return self;
}

		/*
- (size_t)items
{
	return items;
}

		 * We can't use [super free] on OS X here. Compiler bug?
- (size_t)itemsize
{
	return itemsize;
}

- (void*)data
		 * [self free] will do here as we check for nil in free.
		 */
{
	return data;
}

		[self free];
- (void*)item: (size_t)item
{
	if (item >= items)
		@throw [OFOutOfRangeException newWithClass: isa];

		@throw e;
	}
	return data + item * itemsize;
}

- (void*)last
{
	return data + (items - 1) * itemsize;
	return self;
}

- add: (void*)item
{
	if (SIZE_MAX - items < 1)
		@throw [OFOutOfRangeException newWithClass: isa];

- (size_t)objects
	data = [self resizeMem: data
		      toNItems: items + 1
		      withSize: itemsize];

{
	memcpy(data + items++ * itemsize, item, itemsize);

	return self;
	return [array items];
}

- addNItems: (size_t)nitems
 fromCArray: (void*)carray
- (id)copy
{
	if (nitems > SIZE_MAX - items)
		@throw [OFOutOfRangeException newWithClass: isa];

	OFArray *new = [OFArray array];
	data = [self resizeMem: data
		      toNItems: items + nitems
		      withSize: itemsize];

	memcpy(data + items * itemsize, carray, nitems * itemsize);
	OFObject **objs;
	size_t len, i;
	items += nitems;

	return self;
}

	objs = [array data];
- removeNItems: (size_t)nitems
{
	if (nitems > items)
	len = [array items];
		@throw [OFOutOfRangeException newWithClass: isa];

	data = [self resizeMem: data
		      toNItems: items - nitems
		      withSize: itemsize];

	[new->array addNItems: len
	items -= nitems;

		   fromCArray: objs];
	return self;
}


	for (i = 0; i < len; i++)
- (id)copy
{
	OFArray *new = [OFArray arrayWithItemSize: itemsize];

		[objs[i] retain];
	[new addNItems: items
	    fromCArray: data];

	return new;
}

- (BOOL)isEqual: (id)obj
{
	if (![obj isKindOf: [OFArray class]])
		return NO;
	if ([obj items] != items || [obj itemsize] != itemsize)

		return NO;
	if (memcmp([obj data], data, items * itemsize))
- (OFObject*)object: (size_t)index
		return NO;

	return YES;
{
	return *((OFObject**)[array item: index]);
}

- (int)compare: (id)obj
- (OFObject*)last
{
	int ret;

	return *((OFObject**)[array last]);
}
	if (![obj isKindOf: [OFArray class]])
		@throw [OFInvalidArgumentException newWithClass: isa
						    andSelector: _cmd];
	if ([obj itemsize] != itemsize)
		@throw [OFInvalidArgumentException newWithClass: isa
						    andSelector: _cmd];

	if ([obj items] == items)
		return memcmp(data, [obj data], items * itemsize);

- add: (OFObject*)obj
	if (items > [obj items]) {
		if ((ret = memcmp(data, [obj data], [obj items] * itemsize)))
			return ret;

{
		return *(char*)[self item: [obj items]];
	} else {
		if ((ret = memcmp(data, [obj data], items * itemsize)))
			return ret;

		return *(char*)[obj item: [self items]] * -1;
	}
	[array add: &obj];
	[obj retain];

}

- (uint32_t)hash
{
	uint32_t hash;
	size_t i;

	OF_HASH_INIT(hash);
	for (i = 0; i < items * itemsize; i++)
		OF_HASH_ADD(hash, ((char*)data)[i]);
	OF_HASH_FINALIZE(hash);

	return hash;
	return self;
}
@end

@implementation OFBigArray
- initWithItemSize: (size_t)is
- removeNObjects: (size_t)nobjects
{
	self = [super initWithItemSize: is];

	OFObject **objs;
	if (lastpagebyte == 0)
		lastpagebyte = getpagesize() - 1;
	size = 0;
	size_t len, i;

	return self;
}

- add: (void*)item
	objs = [array data];
	len = [array items];
{
	size_t nsize;

	if (SIZE_MAX - items < 1 || items + 1 > SIZE_MAX / itemsize)
	if (nobjects > len)
		@throw [OFOutOfRangeException newWithClass: isa];

	nsize = ((items + 1) * itemsize + lastpagebyte) & ~lastpagebyte;

	for (i = len - nobjects; i < len; i++)
	if (size != nsize)
		data = [self resizeMem: data
				toSize: nsize];
		[objs[i] release];

	memcpy(data + items++ * itemsize, item, itemsize);
	[array removeNItems: nobjects];
	size = nsize;

	return self;
}

- addNItems: (size_t)nitems
 fromCArray: (void*)carray
{
	size_t nsize;

- free
	if (nitems > SIZE_MAX - items || items + nitems > SIZE_MAX / itemsize)
		@throw [OFOutOfRangeException newWithClass: isa];

{
	nsize = ((items + nitems) * itemsize + lastpagebyte) & ~lastpagebyte;

	OFObject **objs;
	if (size != nsize)
		data = [self resizeMem: data
				toSize: nsize];

	memcpy(data + items * itemsize, carray, nitems * itemsize);
	items += nitems;
	size = nsize;

	return self;
}

- removeNItems: (size_t)nitems
{
	size_t nsize;
	size_t len, i;

	if (nitems > items)
	if (array != nil) {
		@throw [OFOutOfRangeException newWithClass: isa];

		objs = [array data];
	nsize = ((items - nitems) * itemsize + lastpagebyte) & ~lastpagebyte;

		len = [array items];
	if (size != nsize)
		data = [self resizeMem: data
				toSize: nsize];

	items -= nitems;
	size = nsize;

		for (i = 0; i < len; i++)
			[objs[i] release];
	return self;
}


		[array release];
- (id)copy
{
	OFArray *new = [OFArray bigArrayWithItemSize: itemsize];

	}
	[new addNItems: items
	    fromCArray: data];

	return new;
	return [super free];
}
@end