ObjFW  Check-in [756bb26c98]

	@try {
		OFAutoreleasePool *pool, *pool2;
		OFEnumerator *enumerator;
		OFXMLElement *child;

		pool = [[OFAutoreleasePool alloc] init];

		if (![[element name] isEqual: @"object"] ||
		    ![[element namespace] isEqual: OF_SERIALIZATION_NS] ||
		if (![[element name] isEqual: [self className]] ||
		    ![[element namespace] isEqual: OF_SERIALIZATION_NS])
		    ![[[element attributeForName: @"class"] stringValue]
		    isEqual: [self className]])
			@throw [OFInvalidArgumentException newWithClass: isa
							       selector: _cmd];

		enumerator = [[element
		enumerator = [[element children] objectEnumerator];
		    elementsForName: @"object"
			  namespace: OF_SERIALIZATION_NS] objectEnumerator];
		pool2 = [[OFAutoreleasePool alloc] init];

		while ((child = [enumerator nextObject]) != nil) {
			id object = [child objectByDeserializing];
			id object;

			if (![[child namespace] isEqual: OF_SERIALIZATION_NS])
				continue;

			object = [child objectByDeserializing];
			[array addItem: &object];
			[object retain];

			[pool2 releaseObjects];
		}

		[pool release];

	 */
	ret->isa = [OFString class];
	return ret;
}

- (OFXMLElement*)XMLElementBySerializing
{
	OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
	OFAutoreleasePool *pool;
	OFAutoreleasePool *pool2;
	OFXMLElement *element;
	id <OFSerialization> *cArray = [array cArray];
	size_t i, count = [array count];

	element = [OFXMLElement elementWithName: @"object"
				      namespace: OF_SERIALIZATION_NS];
	element = [[OFXMLElement alloc] initWithName: [self className]
					   namespace: OF_SERIALIZATION_NS];

	pool = [[OFAutoreleasePool alloc] init];
	pool2 = [[OFAutoreleasePool alloc] init];
	[element addAttributeWithName: @"class"
			  stringValue: [self className]];

	for (i = 0; i < count; i++) {
		[element addChild: [cArray[i] XMLElementBySerializing]];

		[pool releaseObjects];
		[pool2 releaseObjects];
	}

	[element retain];
	@try {
	[pool release];
		[pool release];
	} @finally {
		[element autorelease];
	}

	return element;
}

- (void)makeObjectsPerformSelector: (SEL)selector
{
	id *cArray = [array cArray];

- initWithSerialization: (OFXMLElement*)element
{
	self = [super init];

	@try {
		OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
		OFXMLElement *secondsElement, *microsecondsElement;
		OFXMLAttribute *secondsAttribute, *microsecondsAttribute;

		if (![[element name] isEqual: @"object"] ||
		    ![[element namespace] isEqual: OF_SERIALIZATION_NS] ||
		if (![[element name] isEqual: [self className]] ||
		    ![[element namespace] isEqual: OF_SERIALIZATION_NS])
		    ![[[element attributeForName: @"class"] stringValue]
		    isEqual: [self className]])
			@throw [OFInvalidArgumentException newWithClass: isa
							       selector: _cmd];

		secondsElement = [element elementForName: @"seconds"
		secondsAttribute = [element attributeForName: @"seconds"];
					       namespace: OF_SERIALIZATION_NS];
		microsecondsElement = [element
		    elementForName: @"microseconds"
		microsecondsAttribute =
		    [element attributeForName: @"microseconds"];
			 namespace: OF_SERIALIZATION_NS];

		if (secondsElement == nil || microsecondsElement == nil)
		if (secondsAttribute == nil || microsecondsAttribute == nil)
			@throw [OFInvalidArgumentException newWithClass: isa
							       selector: _cmd];

		seconds = (int64_t)[secondsElement decimalValue];
		microseconds = (uint32_t)[microsecondsElement decimalValue];
		seconds = (int64_t)[secondsAttribute decimalValue];
		microseconds = (uint32_t)[microsecondsAttribute decimalValue];

		[pool release];
	} @catch (id e) {
		[self release];
		@throw e;
	}

- (OFString*)description
{
	return [self dateStringWithFormat: @"%Y-%m-%dT%H:%M:%SZ"];
}

- (OFXMLElement*)XMLElementBySerializing
{
	OFAutoreleasePool *pool;
	OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
	OFXMLElement *element;
	OFString *secondsString, *microsecondsString;

	element = [OFXMLElement elementWithName: @"object"
	element = [OFXMLElement elementWithName: [self className]
				      namespace: OF_SERIALIZATION_NS];

	secondsString = [OFString stringWithFormat: @"%" @PRId64, seconds];
	microsecondsString = [OFString stringWithFormat: @"%" @PRId64,
							 microseconds];
	pool = [[OFAutoreleasePool alloc] init];
	[element addAttributeWithName: @"class"
			  stringValue: [self className]];

	[element addAttributeWithName: @"seconds"
			  stringValue: secondsString];
	[element addAttributeWithName: @"microseconds"
			  stringValue: microsecondsString];

	[element addChild:
	    [OFXMLElement elementWithName: @"seconds"
	[element retain];
	@try {
		[pool release];
				namespace: OF_SERIALIZATION_NS
			      stringValue: [OFString stringWithFormat:
					       @"%" @PRId64, seconds]]];
	[element addChild:
	} @finally {
		[element autorelease];
	    [OFXMLElement elementWithName: @"microseconds"
				namespace: OF_SERIALIZATION_NS
			      stringValue: [OFString stringWithFormat:
					       @"%" @PRIu32, microseconds]]];

	}
	[pool release];

	return element;
}

- (uint32_t)microsecond
{
	return microseconds;

#import "OFArray.h"
#import "OFString.h"
#import "OFXMLElement.h"
#import "OFAutoreleasePool.h"

#import "OFEnumerationMutationException.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFOutOfRangeException.h"

#import "macros.h"

struct of_dictionary_bucket of_dictionary_deleted_bucket = {};

#define DELETED &of_dictionary_deleted_bucket

	return self;
}

- initWithSerialization: (OFXMLElement*)element
{
	@try {
		OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
		OFAutoreleasePool *pool, *pool2;
		OFAutoreleasePool *pool2;
		OFMutableDictionary *dictionary;
		OFArray *pairs;
		OFEnumerator *enumerator;
		OFXMLElement *pair;
		OFArray *keys, *objects;
		OFEnumerator *keyEnumerator, *objectEnumerator;
		OFXMLElement *keyElement, *objectElement;

		pool = [[OFAutoreleasePool alloc] init];

		if (![[element name] isEqual: @"object"] ||
		    ![[element namespace] isEqual: OF_SERIALIZATION_NS] ||
		if (![[element name] isEqual: [self className]] ||
		    ![[element namespace] isEqual: OF_SERIALIZATION_NS])
		    ![[[element attributeForName: @"class"] stringValue]
		    isEqual: [self className]])
			@throw [OFInvalidArgumentException newWithClass: isa
							       selector: _cmd];

		dictionary = [OFMutableDictionary dictionary];

		pairs = [element elementsForName: @"pair"
				       namespace: OF_SERIALIZATION_NS];
		keys = [element elementsForName: @"key"
				      namespace: OF_SERIALIZATION_NS];
		objects = [element elementsForName: @"object"
					 namespace: OF_SERIALIZATION_NS];

		if ([keys count] != [objects count])
			@throw [OFInvalidFormatException newWithClass: isa];

		enumerator = [pairs objectEnumerator];
		keyEnumerator = [keys objectEnumerator];
		objectEnumerator = [objects objectEnumerator];
		pool2 = [[OFAutoreleasePool alloc] init];

		while ((keyElement = [keyEnumerator nextObject]) != nil &&
		while ((pair = [enumerator nextObject]) != nil) {
			OFXMLElement *keyElement, *valueElement;
		    (objectElement = [objectEnumerator nextObject]) != nil) {
			OFXMLElement *key, *object;
			id <OFSerialization, OFCopying> key;
			id <OFSerialization> object;

			keyElement = [pair elementForName: @"key"
						namespace: OF_SERIALIZATION_NS];
			valueElement = [pair
			key = [[keyElement elementsForNamespace:
			    OF_SERIALIZATION_NS] firstObject];
			object = [[objectElement elementsForNamespace:
			    elementForName: @"value"
				 namespace: OF_SERIALIZATION_NS];
			    OF_SERIALIZATION_NS] firstObject];

			if (keyElement == nil || valueElement == nil)
				@throw [OFInvalidArgumentException
				    newWithClass: isa
			if (key == nil || object == nil)
				@throw [OFInvalidFormatException
				    newWithClass: isa];
					selector: _cmd];

			key = [[keyElement elementForName: @"object"
						namespace: OF_SERIALIZATION_NS]
			    objectByDeserializing];
			[dictionary setObject: [object objectByDeserializing]
			object = [[valueElement
			    elementForName: @"object"
				 namespace: OF_SERIALIZATION_NS]
			    objectByDeserializing];
				       forKey: [key objectByDeserializing]];

			[dictionary setObject: object
				       forKey: key];

			[pool2 releaseObjects];
		}

		self = [self initWithDictionary: dictionary];

		[pool release];

	 */
	ret->isa = [OFString class];
	return ret;
}

- (OFXMLElement*)XMLElementBySerializing
{
	OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
	OFAutoreleasePool *pool, *pool2;
	OFAutoreleasePool *pool2;
	OFXMLElement *element;
	OFEnumerator *keyEnumerator, *objectEnumerator;
	id <OFSerialization> key, object;

	element = [OFXMLElement elementWithName: @"object"
	element = [OFXMLElement elementWithName: [self className]
				      namespace: OF_SERIALIZATION_NS];

	pool = [[OFAutoreleasePool alloc] init];
	[element addAttributeWithName: @"class"
			  stringValue: [self className]];

	keyEnumerator = [self keyEnumerator];
	objectEnumerator = [self objectEnumerator];

	pool2 = [[OFAutoreleasePool alloc] init];

	while ((key = [keyEnumerator nextObject]) != nil &&
	       (object = [objectEnumerator nextObject]) != nil) {
		OFXMLElement *pair, *keyElement, *valueElement;
		OFXMLElement *keyElement, *objectElement;

		pair = [OFXMLElement elementWithName: @"pair"
					   namespace: OF_SERIALIZATION_NS];

		keyElement = [OFXMLElement
		    elementWithName: @"key"
			  namespace: OF_SERIALIZATION_NS];
		[keyElement addChild: [key XMLElementBySerializing]];
		[pair addChild: keyElement];

		valueElement = [OFXMLElement
		    elementWithName: @"value"
		objectElement = [OFXMLElement
		    elementWithName: @"object"
			  namespace: OF_SERIALIZATION_NS];
		[valueElement addChild: [object XMLElementBySerializing]];
		[objectElement addChild: [object XMLElementBySerializing]];
		[pair addChild: valueElement];

		[element addChild: pair];
		[element addChild: keyElement];
		[element addChild: objectElement];

		[pool2 releaseObjects];
	}

	[element retain];
	@try {
	[pool release];
		[pool release];
	} @finally {
		[element autorelease];
	}

	return element;
}
@end

@implementation OFDictionaryEnumerator
- initWithDictionary: (OFDictionary*)dictionary_

}

- initWithSerialization: (OFXMLElement*)element
{
	self = [self init];

	@try {
		OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
		OFAutoreleasePool *pool, *pool2;
		OFAutoreleasePool *pool2;
		OFEnumerator *enumerator;
		OFXMLElement *child;

		pool = [[OFAutoreleasePool alloc] init];

		if (![[element name] isEqual: @"object"] ||
		    ![[element namespace] isEqual: OF_SERIALIZATION_NS] ||
		if (![[element name] isEqual: [self className]] ||
		    ![[element namespace] isEqual: OF_SERIALIZATION_NS])
		    ![[[element attributeForName: @"class"] stringValue]
		    isEqual: [self className]])
			@throw [OFInvalidArgumentException newWithClass: isa
							       selector: _cmd];

		enumerator = [[element
		enumerator = [[element children] objectEnumerator];
		    elementsForName: @"object"
			  namespace: OF_SERIALIZATION_NS] objectEnumerator];
		pool2 = [[OFAutoreleasePool alloc] init];

		while ((child = [enumerator nextObject]) != nil) {
			id object = [child objectByDeserializing];
			if (![[child namespace] isEqual: OF_SERIALIZATION_NS])
				continue;

			[self appendObject: object];
			[self appendObject: [child objectByDeserializing]];

			[pool2 releaseObjects];
		}

		[pool release];
	} @catch (id e) {
		[self release];

	 */
	ret->isa = [OFString class];
	return ret;
}

- (OFXMLElement*)XMLElementBySerializing
{
	OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
	OFAutoreleasePool *pool;
	OFAutoreleasePool *pool2;
	OFXMLElement *element;
	of_list_object_t *iter;

	element = [OFXMLElement elementWithName: @"object"
	element = [OFXMLElement elementWithName: [self className]
				      namespace: OF_SERIALIZATION_NS];

	pool = [[OFAutoreleasePool alloc] init];
	pool2 = [[OFAutoreleasePool alloc] init];
	[element addAttributeWithName: @"class"
			  stringValue: [self className]];

	for (iter = firstListObject; iter != NULL; iter = iter->next) {
		[element addChild: [iter->object XMLElementBySerializing]];

		[pool releaseObjects];
		[pool2 releaseObjects];
	}

	[element retain];
	@try {
	[pool release];
		[pool release];
	} @finally {
		[element autorelease];
	}

	return element;
}

- (int)countByEnumeratingWithState: (of_fast_enumeration_state_t*)state
			   objects: (id*)objects
			     count: (int)count_

{
	OFAutoreleasePool *pool;

	[self release];

	pool = [[OFAutoreleasePool alloc] init];

	if (![[element name] isEqual: @"object"] ||
	    ![[element namespace] isEqual: OF_SERIALIZATION_NS] ||
	if (![[element name] isEqual: [self className]] ||
	    ![[element namespace] isEqual: OF_SERIALIZATION_NS])
	    ![[[element attributeForName: @"class"] stringValue]
	    isEqual: [self className]])
		@throw [OFInvalidArgumentException newWithClass: isa
						       selector: _cmd];

	[pool release];

	return [OFNull null];
}

- (OFString*)description
{
	return @"<null>";
}

- copy
{
	return self;
}

- (OFXMLElement*)XMLElementBySerializing
{
	OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
	OFXMLElement *element;

	element = [OFXMLElement elementWithName: @"object"
	element = [OFXMLElement elementWithName: [self className]
				      namespace: OF_SERIALIZATION_NS];

	[element addAttributeWithName: @"class"
			  stringValue: [self className]];
	[element retain];
	@try {
		[pool release];
	} @finally {
		[element autorelease];
	}

	return element;
}

- autorelease
{
	return self;

{
	self = [super init];

	@try {
		OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
		OFString *typeString;

		if (![[element name] isEqual: @"object"] ||
		    ![[element namespace] isEqual: OF_SERIALIZATION_NS] ||
		if (![[element name] isEqual: [self className]] ||
		    ![[element namespace] isEqual: OF_SERIALIZATION_NS])
		    ![[[element attributeForName: @"class"] stringValue]
		    isEqual: [self className]])
			@throw [OFInvalidArgumentException newWithClass: isa
							       selector: _cmd];

		typeString = [[element attributeForName: @"type"] stringValue];

		if ([typeString isEqual: @"boolean"]) {
			type = OF_NUMBER_BOOL;

	default:
		@throw [OFInvalidFormatException newWithClass: isa];
	}
}

- (OFXMLElement*)XMLElementBySerializing
{
	OFAutoreleasePool *pool;
	OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
	OFXMLElement *element;

	element = [OFXMLElement elementWithName: @"object"
				      namespace: OF_SERIALIZATION_NS];
	element = [OFXMLElement elementWithName: [self className]
				      namespace: OF_SERIALIZATION_NS

	pool = [[OFAutoreleasePool alloc] init];

	[element addAttributeWithName: @"class"
			  stringValue: [self className]];
				    stringValue: [self description]];
	[element setStringValue: [self description]];

	switch (type) {
	case OF_NUMBER_BOOL:
		[element addAttributeWithName: @"type"
				  stringValue: @"boolean"];
		break;
	case OF_NUMBER_UCHAR:

		    [OFString stringWithFormat: @"%" PRIX64, d.i]];

		break;
	default:
		@throw [OFInvalidFormatException newWithClass: isa];
	}

	[element retain];
	@try {
	[pool release];
		[pool release];
	} @finally {
		[element autorelease];
	}

	return element;
}
@end

			selector: @selector(stringBySerializing)];

	pool = [[OFAutoreleasePool alloc] init];
	element = [(id)self XMLElementBySerializing];

	root = [OFXMLElement elementWithName: @"serialization"
				   namespace: OF_SERIALIZATION_NS];
	[root addAttributeWithName: @"version"
		       stringValue: @"0"];
	[root addChild: element];

	ret = [@"<?xml version='1.0' encoding='UTF-8'?>\n"
	    stringByAppendingString: [root XMLStringWithIndentation: 2]];
	[ret retain];

	[ret retain];
	@try {
		[pool release];
	} @catch (id e) {
		[ret release];
	} @finally {
		[ret autorelease];
	}

	return [ret autorelease];
	return ret;
}
@end

- (id)objectByDeserializing
{
	OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
	OFXMLElement *root = [OFXMLElement elementWithXMLString: self];
	OFArray *elements;
	id object;

	elements = [root elementsForName: @"object"
	elements = [root elementsForNamespace: OF_SERIALIZATION_NS];
			       namespace: OF_SERIALIZATION_NS];

	if ([elements count] != 1)
		@throw [OFInvalidArgumentException newWithClass: isa
						       selector: _cmd];

	object = [[[elements firstObject] objectByDeserializing] retain];

}

- initWithSerialization: (OFXMLElement*)element
{
	@try {
		OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];

		if (![[element name] isEqual: @"object"] ||
		    ![[element namespace] isEqual: OF_SERIALIZATION_NS] ||
		if (![[element name] isEqual: [self className]] ||
		    ![[element namespace] isEqual: OF_SERIALIZATION_NS])
		    ![[[element attributeForName: @"class"] stringValue]
		    isEqual: [self className]])
			@throw [OFInvalidArgumentException newWithClass: isa
							       selector: _cmd];

		self = [self initWithString: [element stringValue]];

		[pool release];
	} @catch (id e) {

- (OFString*)description
{
	return [[self copy] autorelease];
}

- (OFXMLElement*)XMLElementBySerializing
{
	OFAutoreleasePool *pool;
	OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
	OFXMLElement *element;
	OFString *className;

	if ([self isKindOfClass: [OFConstantString class]])
		className = @"OFString";
	else
		className = [self className];

	element = [OFXMLElement elementWithName: @"object"
	element = [OFXMLElement elementWithName: className
				      namespace: OF_SERIALIZATION_NS
				    stringValue: self];

	pool = [[OFAutoreleasePool alloc] init];

	if ([self isKindOfClass: [OFConstantString class]])
		[element addAttributeWithName: @"class"
				  stringValue: @"OFString"];
	else
		[element addAttributeWithName: @"class"
	[element retain];
	@try {
		[pool release];
	} @finally {
		[element autorelease];
				  stringValue: [self className]];

	}
	[pool release];

	return element;
}

- (of_unichar_t)characterAtIndex: (size_t)index
{
	of_unichar_t c;

}

- initWithSerialization: (OFXMLElement*)element
{
	@try {
		OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];

		if (![[element name] isEqual: @"object"] ||
		    ![[element namespace] isEqual: OF_SERIALIZATION_NS] ||
		if (![[element name] isEqual: [self className]] ||
		    ![[element namespace] isEqual: OF_SERIALIZATION_NS])
		    ![[[element attributeForName: @"class"] stringValue]
		    isEqual: [self className]])
			@throw [OFInvalidArgumentException newWithClass: isa
							       selector: _cmd];

		self = [self initWithString: [element stringValue]];

		[pool release];
	} @catch (id e) {

- (OFString*)description
{
	return [self string];
}

- (OFXMLElement*)XMLElementBySerializing
{
	OFAutoreleasePool *pool;
	OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
	OFXMLElement *element;

	element = [OFXMLElement elementWithName: @"object"
				      namespace: OF_SERIALIZATION_NS];

	element = [OFXMLElement elementWithName: [self className]
				      namespace: OF_SERIALIZATION_NS
				    stringValue: [self string]];
	pool = [[OFAutoreleasePool alloc] init];

	[element addAttributeWithName: @"class"
			  stringValue: [self className]];
	[element setStringValue: [self string]];

	[element retain];
	@try {
		[pool release];
	} @finally {
		[element autorelease];
	}
	[pool release];

	return element;
}
@end

- initWithSerialization: (OFXMLElement*)element
{
	self = [super init];

	@try {
		OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];

		if (![[element name] isEqual: @"object"] ||
		    ![[element namespace] isEqual: OF_SERIALIZATION_NS] ||
		if (![[element name] isEqual: [self className]] ||
		    ![[element namespace] isEqual: OF_SERIALIZATION_NS])
		    ![[[element attributeForName: @"class"] stringValue]
		    isEqual: [self className]])
			@throw [OFInvalidArgumentException newWithClass: isa
							       selector: _cmd];

		name = [[[element
		    elementForName: @"name"
		name = [[[element attributeForName: @"name"] stringValue]
		    copy];
			 namespace: OF_SERIALIZATION_NS] stringValue] retain];
		ns = [[[element
		ns = [[[element attributeForName: @"namespace"] stringValue]
		    elementForName: @"namespace"
			 namespace: OF_SERIALIZATION_NS] stringValue] retain];
		stringValue = [[[element
		    elementForName: @"stringValue"
		    copy];
		stringValue = [[[element attributeForName: @"stringValue"]
		    stringValue] copy];
			 namespace: OF_SERIALIZATION_NS] stringValue] retain];

		[pool release];
	} @catch (id e) {
		[self release];
		@throw e;
	}

	OF_HASH_FINALIZE(hash);

	return hash;
}

- (OFXMLElement*)XMLElementBySerializing
{
	OFAutoreleasePool *pool;
	OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
	OFXMLElement *element;

	element = [OFXMLElement elementWithName: @"object"
	element = [OFXMLElement elementWithName: [self className]
				      namespace: OF_SERIALIZATION_NS];

	pool = [[OFAutoreleasePool alloc] init];

	[element addAttributeWithName: @"class"
			  stringValue: [self className]];
	[element addAttributeWithName: @"name"
			  stringValue: name];

	[element addChild:
	    [OFXMLElement elementWithName: @"name"
				namespace: OF_SERIALIZATION_NS
			      stringValue: name]];
	if (ns != nil)
		[element addChild:
		[element addAttributeWithName: @"namespace"
		    [OFXMLElement elementWithName: @"namespace"
					namespace: OF_SERIALIZATION_NS
				      stringValue: ns]];
	[element addChild:
	    [OFXMLElement elementWithName: @"stringValue"
				  stringValue: ns];

	[element addAttributeWithName: @"stringValue"
				namespace: OF_SERIALIZATION_NS
			      stringValue: stringValue]];
			  stringValue: stringValue];

	[element retain];
	@try {
	[pool release];
		[pool release];
	} @finally {
		[element autorelease];
	}

	return element;
}
@end

int _OFXMLElement_Serialization_reference;

@implementation OFXMLElement (Serialization)
- (id)objectByDeserializing
{
	OFAutoreleasePool *pool;
	OFString *className;
	Class class;
	id <OFSerialization> object;

	pool = [[OFAutoreleasePool alloc] init];
	className = [[self attributeForName: @"class"] stringValue];
	if (className == nil)
		@throw [OFNotImplementedException
		    newWithClass: nil
			selector: @selector(initWithSerialization:)];

	class = objc_lookUpClass([className cString]);
	if ((class = objc_lookUpClass([name cString])) == Nil)
	if (class == Nil)
		@throw [OFNotImplementedException newWithClass: Nil];

	if (![class conformsToProtocol: @protocol(OFSerialization)])
		@throw [OFNotImplementedException
		    newWithClass: class
			selector: @selector(initWithSerialization:)];

	object = [[class alloc] initWithSerialization: self];

	@try {
		[pool release];
	} @catch (id e) {
		[object release];
	} @finally {
		[object autorelease];
		@throw e;
	}

	return [object autorelease];
	return object;
}
@end

#import "OFDictionary.h"
#import "OFXMLAttribute.h"
#import "OFXMLParser.h"
#import "OFXMLElementBuilder.h"
#import "OFAutoreleasePool.h"

#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFMalformedXMLException.h"
#import "OFNotImplementedException.h"
#import "OFUnboundNamespaceException.h"

#import "macros.h"

/* References for static linking */

	self = [super init];

	@try {
		OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
		OFXMLElement *attributesElement, *namespacesElement;
		OFXMLElement *childrenElement;

		if (![[element name] isEqual: @"object"] ||
		    ![[element namespace] isEqual: OF_SERIALIZATION_NS] ||
		if (![[element name] isEqual: [self className]] ||
		    ![[element namespace] isEqual: OF_SERIALIZATION_NS])
		    ![[[element attributeForName: @"class"] stringValue]
		    isEqual: [self className]])
			@throw [OFInvalidArgumentException newWithClass: isa
							       selector: _cmd];

		name = [[[element
		name = [[[element attributeForName: @"name"] stringValue] copy];
		    elementForName: @"name"
			 namespace: OF_SERIALIZATION_NS] stringValue] copy];
		ns = [[[element
		ns = [[[element attributeForName: @"namespace"] stringValue]
		    elementForName: @"namespace"
			namespace: OF_SERIALIZATION_NS] stringValue] copy];
		defaultNamespace = [[[element
		    elementForName: @"defaultNamespace"
		    copy];
		defaultNamespace = [[[element attributeForName:
		    @"defaultNamespace"] stringValue] copy];
			 namespace: OF_SERIALIZATION_NS] stringValue] copy];
		characters = [[[element
		    elementForName: @"characters"
			 namespace: OF_SERIALIZATION_NS] stringValue] copy];
		CDATA = [[[element
		    elementForName: @"CDATA"
			 namespace: OF_SERIALIZATION_NS] stringValue] copy];
		comment = [[[element
		    elementForName: @"comment"
			 namespace: OF_SERIALIZATION_NS] stringValue] copy];

		attributesElement = [element
		attributesElement = [[[element
		    elementForName: @"attributes"
			 namespace: OF_SERIALIZATION_NS];
		namespacesElement = [element
			 namespace: OF_SERIALIZATION_NS] elementsForNamespace:
		    OF_SERIALIZATION_NS] firstObject];
		namespacesElement = [[[element
		    elementForName: @"namespaces"
			 namespace: OF_SERIALIZATION_NS];
			 namespace: OF_SERIALIZATION_NS] elementsForNamespace:
		childrenElement = [element elementForName: @"children"
						namespace: OF_SERIALIZATION_NS];

		    OF_SERIALIZATION_NS] firstObject];
		childrenElement = [[[element
		attributes = [[[attributesElement
		    elementForName: @"object"
			 namespace: OF_SERIALIZATION_NS] objectByDeserializing]
		    elementForName: @"children"
			 namespace: OF_SERIALIZATION_NS] elementsForNamespace:
		    retain];
		namespaces = [[[namespacesElement
		    elementForName: @"object"
			 namespace: OF_SERIALIZATION_NS] objectByDeserializing]
		    retain];
		children = [[[childrenElement
		    elementForName: @"object"
			 namespace: OF_SERIALIZATION_NS] objectByDeserializing]
		    OF_SERIALIZATION_NS] firstObject];

		attributes = [[attributesElement objectByDeserializing] copy];
		namespaces = [[namespacesElement objectByDeserializing] copy];
		children = [[childrenElement objectByDeserializing] copy];
		    retain];

		if (!((name != nil || ns != nil || defaultNamespace != nil ||
		    [attributes count] > 0 || [namespaces count] > 0 ||
		    [children count] > 0) ^ (characters != nil) ^
		    (CDATA != nil) ^ (comment != nil)))
			@throw [OFInvalidArgumentException newWithClass: isa
							       selector: _cmd];

- (OFString*)description
{
	return [self XMLStringWithIndentation: 2];
}

- (OFXMLElement*)XMLElementBySerializing
{
	OFAutoreleasePool *pool;
	OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
	OFXMLElement *element;

	element = [OFXMLElement elementWithName: @"object"
	element = [OFXMLElement elementWithName: [self className]
				      namespace: OF_SERIALIZATION_NS];

	pool = [[OFAutoreleasePool alloc] init];

	[element addAttributeWithName: @"class"
			  stringValue: [self className]];

	if (name != nil)
		[element addChild:
		[element addAttributeWithName: @"name"
		    [OFXMLElement elementWithName: @"name"
					namespace: OF_SERIALIZATION_NS
				      stringValue: name]];
				  stringValue: name];

	if (ns != nil)
		[element addChild:
		[element addAttributeWithName: @"namespace"
		    [OFXMLElement elementWithName: @"namespace"
					namespace: OF_SERIALIZATION_NS
				      stringValue: ns]];
				  stringValue: ns];

	if (defaultNamespace != nil)
		[element addChild:
		    [OFXMLElement elementWithName: @"defaultNamespace"
		[element addAttributeWithName: @"defaultNamespace"
					namespace: OF_SERIALIZATION_NS
				      stringValue: defaultNamespace]];
				  stringValue: defaultNamespace];

	if (attributes != nil) {
		OFXMLElement *attributesElement;

		attributesElement =
		    [OFXMLElement elementWithName: @"attributes"
					namespace: OF_SERIALIZATION_NS];

	if (characters != nil)
		[element addChild:
		    [OFXMLElement elementWithName: @"characters"
					namespace: OF_SERIALIZATION_NS
				      stringValue: characters]];

	if (CDATA != nil)
		[element addChild:
	if (CDATA != nil) {
		OFXMLElement *CDATAElement =
		    [OFXMLElement elementWithName: @"CDATA"
					namespace: OF_SERIALIZATION_NS
				      stringValue: CDATA]];
					namespace: OF_SERIALIZATION_NS];
		[CDATAElement addChild: [OFXMLElement elementWithCDATA: CDATA]];
		[element addChild: CDATAElement];
	}

	if (comment != nil)
		[element addChild:
		    [OFXMLElement elementWithName: @"comment"
					namespace: OF_SERIALIZATION_NS
				      stringValue: comment]];

	[element retain];
	@try {
	[pool release];
		[pool release];
	} @finally {
		[element autorelease];
	}

	return element;
}

- (void)addAttribute: (OFXMLAttribute*)attribute
{
	if (name == nil)

	      forKey: a];
	[d setObject: @"B\"la"
	      forKey: @"Blub"];

	[l appendObject: @"Hello"];
	[l appendObject: @"Wo\rld!\nHow are you?"];
	[l appendObject: [OFURL URLWithString: @"https://webkeks.org/"]];
	[l appendObject:
	[l appendObject: [OFXMLElement elementWithXMLString: @"<x><y/></x>"]];
	    [OFXMLElement elementWithXMLString: @"<x><y/><![CDATA[<]]></x>"]];

	[d setObject: @"list"
	      forKey: l];

	TEST(@"-[stringBySerializing]",
	    (s = [d stringBySerializing]) && [s isEqual:
	    [OFString stringWithContentsOfFile: @"serialization.xml"]])

<?xml version='1.0' encoding='UTF-8'?>
<serialization xmlns='https://webkeks.org/objfw/serialization'>
  <object class='OFMutableDictionary'>
<serialization xmlns='https://webkeks.org/objfw/serialization' version='0'>
  <OFMutableDictionary>
    <pair>
      <key>
        <object class='OFArray'>
          <object class='OFString'>Qu&quot;xbar
test</object>
          <object class='OFNumber' type='signed'>1234</object>
          <object class='OFMutableString'>asd</object>
    <key>
      <OFArray>
        <OFString>Qu&quot;xbar
test</OFString>
        <OFNumber type='signed'>1234</OFNumber>
        <OFMutableString>asd</OFMutableString>
          <object class='OFDate'>
            <seconds>1234</seconds>
            <microseconds>5678</microseconds>
        <OFDate seconds='1234' microseconds='5678'/>
          </object>
        </object>
      </key>
      </OFArray>
      <value>
        <object class='OFString'>Hello</object>
      </value>
    </pair>
    <pair>
      <key>
        <object class='OFString'>Blub</object>
      </key>
    </key>
      <value>
        <object class='OFString'>B&quot;la</object>
      </value>
    </pair>
    <object>
      <OFString>Hello</OFString>
    </object>
    <pair>
      <key>
        <object class='OFList'>
          <object class='OFString'>Hello</object>
          <object class='OFString'>Wo&#xD;ld!
How are you?</object>
          <object class='OFURL'>https://webkeks.org/</object>
          <object class='OFXMLElement'>
    <key>
      <OFList>
        <OFString>Hello</OFString>
        <OFString>Wo&#xD;ld!
How are you?</OFString>
        <OFURL>https://webkeks.org/</OFURL>
        <OFXMLElement name='x'>
            <name>x</name>
            <namespaces>
              <object class='OFMutableDictionary'>
          <namespaces>
            <OFMutableDictionary>
                <pair>
                  <key>
                    <object class='OFString'>http://www.w3.org/2000/xmlns/</object>
                  </key>
              <key>
                <OFString>http://www.w3.org/2000/xmlns/</OFString>
              </key>
                  <value>
                    <object class='OFString'>xmlns</object>
                  </value>
              <object>
                <OFString>xmlns</OFString>
              </object>
              <key>
                <OFString>http://www.w3.org/XML/1998/namespace</OFString>
                </pair>
                <pair>
                  <key>
                    <object class='OFString'>http://www.w3.org/XML/1998/namespace</object>
                  </key>
              </key>
                  <value>
                    <object class='OFString'>xml</object>
              <object>
                  </value>
                </pair>
                <OFString>xml</OFString>
              </object>
            </OFMutableDictionary>
            </namespaces>
            <children>
              <object class='OFMutableArray'>
                <object class='OFXMLElement'>
          </namespaces>
          <children>
            <OFMutableArray>
              <OFXMLElement name='y'>
                  <name>y</name>
                  <namespaces>
                    <object class='OFMutableDictionary'>
                <namespaces>
                  <OFMutableDictionary>
                      <pair>
                        <key>
                          <object class='OFString'>http://www.w3.org/2000/xmlns/</object>
                        </key>
                        <value>
                          <object class='OFString'>xmlns</object>
                    <key>
                      <OFString>http://www.w3.org/2000/xmlns/</OFString>
                    </key>
                    <object>
                      <OFString>xmlns</OFString>
                    </object>
                    <key>
                      <OFString>http://www.w3.org/XML/1998/namespace</OFString>
                    </key>
                    <object>
                      <OFString>xml</OFString>
                        </value>
                      </pair>
                      <pair>
                        <key>
                          <object class='OFString'>http://www.w3.org/XML/1998/namespace</object>
                        </key>
                        <value>
                          <object class='OFString'>xml</object>
                        </value>
                      </pair>
                    </object>
                  </OFMutableDictionary>
                  </namespaces>
                </object>
              </object>
            </children>
          </object>
        </object>
      </key>
                </namespaces>
              </OFXMLElement>
              <OFXMLElement>
                <CDATA><![CDATA[<]]></CDATA>
              </OFXMLElement>
            </OFMutableArray>
          </children>
        </OFXMLElement>
      </OFList>
    </key>
    <object>
      <OFString>list</OFString>
    </object>
    <key>
      <OFString>Blub</OFString>
    </key>
      <value>
        <object class='OFString'>list</object>
    <object>
      </value>
    </pair>
  </object>
      <OFString>B&quot;la</OFString>
    </object>
  </OFMutableDictionary>
</serialization>