ObjFW  Check-in [cb0fd980f9]

- (id)objectAtIndexedSubscript: (size_t)index
{
	return [self objectAtIndex: index];
}

- (size_t)indexOfObject: (id)object
{
	size_t i, count;
	size_t i = 0;

	if (object == nil)
		return OF_NOT_FOUND;

	count = [self count];

	for (id objectIter in self) {
	for (i = 0; i < count; i++)
		if ([[self objectAtIndex: i] isEqual: object])
		if ([objectIter isEqual: object])
			return i;

		i++;
	}

	return OF_NOT_FOUND;
}

- (size_t)indexOfObjectIdenticalTo: (id)object
{
	size_t i, count;
	size_t i = 0;

	if (object == nil)
		return OF_NOT_FOUND;

	count = [self count];

	for (id objectIter in self) {
	for (i = 0; i < count; i++)
		if ([self objectAtIndex: i] == object)
		if (objectIter == object)
			return i;

		i++;
	}

	return OF_NOT_FOUND;
}

- (bool)containsObject: (id)object
{
	return ([self indexOfObject: object] != OF_NOT_FOUND);

				      options: 0];
}

- (OFString*)componentsJoinedByString: (OFString*)separator
			usingSelector: (SEL)selector
			      options: (int)options
{
	void *pool;
	OFMutableString *ret;
	id const *objects;
	size_t i, count;

	if (separator == nil)
		@throw [OFInvalidArgumentException exception];

	count = [self count];
	if ([self count] == 0)

	if (count == 0)
		return @"";
	if (count == 1)
	if ([self count] == 1)
		return [[self firstObject] performSelector: selector];

	ret = [OFMutableString string];

	pool = objc_autoreleasePoolPush();
	objects = [self objects];

	if (options & OF_ARRAY_SKIP_EMPTY) {
		for (i = 0; i < count; i++) {
			void *pool2 = objc_autoreleasePoolPush();
		for (id object in self) {
			void *pool = objc_autoreleasePoolPush();
			OFString *component =
			    [objects[i] performSelector: selector];
			    [object performSelector: selector];

			if ([component length] > 0) {
				if ([ret length] > 0)
					[ret appendString: separator];
				[ret appendString: component];
			}

			objc_autoreleasePoolPop(pool2);
			objc_autoreleasePoolPop(pool);
		}
	} else {
		for (i = 0; i < count - 1; i++) {
			void *pool2 = objc_autoreleasePoolPush();
		for (id object in self) {
			void *pool = objc_autoreleasePoolPush();

			if ([ret length] > 0)
			[ret appendString:
				[ret appendString: separator];
			    [objects[i] performSelector: selector]];
			[ret appendString: separator];
			[ret appendString: [object performSelector: selector]];

			objc_autoreleasePoolPop(pool2);
			objc_autoreleasePoolPop(pool);
		}
		[ret appendString: [objects[i] performSelector: selector]];
	}

	[ret makeImmutable];

	objc_autoreleasePoolPop(pool);

	return ret;
}

- (bool)isEqual: (id)object
{
	/* FIXME: Optimize (for example, buffer of 16 for each) */

			return false;

	return true;
}

- (uint32_t)hash
{
	id const *objects = [self objects];
	size_t i, count = [self count];
	uint32_t hash;

	OF_HASH_INIT(hash);

	for (i = 0; i < count; i++)
		OF_HASH_ADD_HASH(hash, [objects[i] hash]);
	for (id object in self)
		OF_HASH_ADD_HASH(hash, [object hash]);

	OF_HASH_FINALIZE(hash);

	return hash;
}

- (OFString*)description

	return [ret autorelease];
}

- (OFXMLElement*)XMLElementBySerializing
{
	void *pool = objc_autoreleasePoolPush();
	OFXMLElement *element;
	id <OFSerialization> const *objects = [self objects];
	size_t i, count = [self count];

	if ([self isKindOfClass: [OFMutableArray class]])
		element = [OFXMLElement elementWithName: @"OFMutableArray"
					      namespace: OF_SERIALIZATION_NS];
	else
		element = [OFXMLElement elementWithName: @"OFArray"
					      namespace: OF_SERIALIZATION_NS];

	for (i = 0; i < count; i++) {
	for (id object in self) {
		void *pool2 = objc_autoreleasePoolPush();

		[element addChild: [objects[i] XMLElementBySerializing]];
		[element addChild: [object XMLElementBySerializing]];

		objc_autoreleasePoolPop(pool2);
	}

	[element retain];

	objc_autoreleasePoolPop(pool);

	objc_autoreleasePoolPop(pool);

	return data;
}

- (void)makeObjectsPerformSelector: (SEL)selector
{
	id const *objects = [self objects];
	size_t i, count = [self count];

	for (id object in self)
	for (i = 0; i < count; i++)
		[objects[i] performSelector: selector];
		[object performSelector: selector];
}

- (void)makeObjectsPerformSelector: (SEL)selector
			withObject: (id)object
{
	id const *objects = [self objects];
	size_t i, count = [self count];

	for (id object in self)
	for (i = 0; i < count; i++)
		[objects[i] performSelector: selector
				 withObject: object];
		[object performSelector: selector
			     withObject: object];
}

- (OFArray*)sortedArray
{
	OFMutableArray *new = [[self mutableCopy] autorelease];

	[new sort];

	    (struct sockaddr*)&_cancelAddr, 8) > 0);
# endif
#endif
}

- (void)OF_processReadBuffers
{
	id const *objects = [_readObjects objects];
	size_t i, count = [_readObjects count];
	for (id object in _readObjects) {

	for (i = 0; i < count; i++) {
		void *pool = objc_autoreleasePoolPush();

		if ([objects[i] isKindOfClass: [OFStream class]] &&
		    [objects[i] hasDataInReadBuffer] &&
		    ![objects[i] OF_isWaitingForDelimiter] &&
		if ([object isKindOfClass: [OFStream class]] &&
		    [object hasDataInReadBuffer] &&
		    ![object OF_isWaitingForDelimiter] &&
		    [_delegate respondsToSelector:
		    @selector(objectIsReadyForReading:)])
			[_delegate objectIsReadyForReading: objects[i]];
			[_delegate objectIsReadyForReading: object];

		objc_autoreleasePoolPop(pool);
	}
}
@end

	objc_autoreleasePoolPop(pool);
}

- (OFString*)stringValue
{
	OFMutableString *ret;
	OFXMLNode *const *objects;
	size_t i, count = [_children count];

	if (count == 0)
	if ([_children count] == 0)
		return @"";

	ret = [OFMutableString string];
	objects = [_children objects];

	for (i = 0; i < count; i++) {
	for (OFXMLNode *child in _children) {
		void *pool = objc_autoreleasePoolPush();

		[ret appendString: [objects[i] stringValue]];
		[ret appendString: [child stringValue]];

		objc_autoreleasePoolPop(pool);
	}

	[ret makeImmutable];

	return ret;

						  stringValue: stringValue]];

	objc_autoreleasePoolPop(pool);
}

- (OFXMLAttribute*)attributeForName: (OFString*)attributeName
{
	OFXMLAttribute *const *objects = [_attributes objects];
	size_t i, count = [_attributes count];

	for (OFXMLAttribute *attribute in _attributes)
	for (i = 0; i < count; i++)
		if (objects[i]->_namespace == nil &&
		    [objects[i]->_name isEqual: attributeName])
			return [[objects[i] retain] autorelease];
		if (attribute->_namespace == nil &&
		    [attribute->_name isEqual: attributeName])
			return [[attribute retain] autorelease];

	return nil;
}

- (OFXMLAttribute*)attributeForName: (OFString*)attributeName
			  namespace: (OFString*)attributeNS
{
	OFXMLAttribute *const *objects;
	size_t i, count;

	if (attributeNS == nil)
		return [self attributeForName: attributeName];

	objects = [_attributes objects];
	count = [_attributes count];

	for (OFXMLAttribute *attribute in _attributes)
	for (i = 0; i < count; i++)
		if ([objects[i]->_namespace isEqual: attributeNS] &&
		    [objects[i]->_name isEqual: attributeName])
			return [[objects[i] retain] autorelease];
		if ([attribute->_namespace isEqual: attributeNS] &&
		    [attribute->_name isEqual: attributeName])
			return [[attribute retain] autorelease];

	return nil;
}

- (void)removeAttributeForName: (OFString*)attributeName
{
	OFXMLAttribute *const *objects = [_attributes objects];

	return [[self elementsForName: elementName
			    namespace: elementNS] firstObject];
}

- (OFArray*)elements
{
	OFMutableArray OF_GENERIC(OFXMLElement*) *ret = [OFMutableArray array];
	OFXMLNode *const *objects = [_children objects];
	size_t i, count = [_children count];

	for (i = 0; i < count; i++)
		if ([objects[i] isKindOfClass: [OFXMLElement class]])
			[ret addObject: (OFXMLElement*)objects[i]];
	for (OFXMLNode *child in _children)
		if ([child isKindOfClass: [OFXMLElement class]])
			[ret addObject: (OFXMLElement*)child];

	[ret makeImmutable];

	return ret;
}

- (OFArray*)elementsForName: (OFString*)elementName
{
	OFMutableArray OF_GENERIC(OFXMLElement*) *ret = [OFMutableArray array];
	OFXMLNode *const *objects = [_children objects];
	size_t i, count = [_children count];

	for (i = 0; i < count; i++) {
		if ([objects[i] isKindOfClass: [OFXMLElement class]]) {
			OFXMLElement *element = (OFXMLElement*)objects[i];
	for (OFXMLNode *child in _children) {
		if ([child isKindOfClass: [OFXMLElement class]]) {
			OFXMLElement *element = (OFXMLElement*)child;

			if (element->_namespace == nil &&
			    [element->_name isEqual: elementName])
				[ret addObject: element];
		}
	}

	[ret makeImmutable];

	return ret;
}

- (OFArray*)elementsForNamespace: (OFString*)elementNS
{
	OFMutableArray OF_GENERIC(OFXMLElement*) *ret = [OFMutableArray array];
	OFXMLNode *const *objects = [_children objects];
	size_t i, count = [_children count];

	for (i = 0; i < count; i++) {
		if ([objects[i] isKindOfClass: [OFXMLElement class]]) {
			OFXMLElement *element = (OFXMLElement*)objects[i];
	for (OFXMLNode *child in _children) {
		if ([child isKindOfClass: [OFXMLElement class]]) {
			OFXMLElement *element = (OFXMLElement*)child;

			if (element->_name != nil &&
			    [element->_namespace isEqual: elementNS])
				[ret addObject: element];
		}
	}

	[ret makeImmutable];

	return ret;
}

- (OFArray*)elementsForName: (OFString*)elementName
		  namespace: (OFString*)elementNS
{
	OFMutableArray OF_GENERIC(OFXMLElement*) *ret;
	OFXMLNode *const *objects;
	size_t i, count;

	if (elementNS == nil)
		return [self elementsForName: elementName];

	ret = [OFMutableArray array];
	objects = [_children objects];
	count = [_children count];

	for (i = 0; i < count; i++) {
		if ([objects[i] isKindOfClass: [OFXMLElement class]]) {
			OFXMLElement *element = (OFXMLElement*)objects[i];
	for (OFXMLNode *child in _children) {
		if ([child isKindOfClass: [OFXMLElement class]]) {
			OFXMLElement *element = (OFXMLElement*)child;

			if ([element->_namespace isEqual: elementNS] &&
			    [element->_name isEqual: elementName])
				[ret addObject: element];
		}
	}

-    (void)parser: (OFXMLParser*)parser
  didStartElement: (OFString*)name
	   prefix: (OFString*)prefix
	namespace: (OFString*)namespace
       attributes: (OFArray*)attributes
{
	OFXMLElement *element;
	OFXMLAttribute *const *objects;
	size_t i, count;

	element = [OFXMLElement elementWithName: name
				      namespace: namespace];
	OFXMLElement *element = [OFXMLElement elementWithName: name
						    namespace: namespace];

	objects = [attributes objects];
	count = [attributes count];

	for (OFXMLAttribute *attribute in attributes) {
	for (i = 0; i < count; i++) {
		if ([objects[i] namespace] == nil &&
		    [[objects[i] name] isEqual: @"xmlns"])
		if ([attribute namespace] == nil &&
		    [[attribute name] isEqual: @"xmlns"])
			continue;

		if ([[objects[i] namespace]
		if ([[attribute namespace]
		    isEqual: @"http://www.w3.org/2000/xmlns/"])
			[element setPrefix: [objects[i] name]
			      forNamespace: [objects[i] stringValue]];
			[element setPrefix: [attribute name]
			      forNamespace: [attribute stringValue]];

		[element addAttribute: objects[i]];
		[element addAttribute: attribute];
	}

	[[_stack lastObject] addChild: element];
	[_stack addObject: element];
}

-  (void)parser: (OFXMLParser*)parser