ObjFW  Diff

	return [self isEqual: object];
}

- (uint32_t)hash
{
	[self finishInitialization];

	return [self hash];
	return self.hash;
}

- (OFString *)description
{
	[self finishInitialization];

	return [self description];
	return self.description;
}

/* From OFString */
- (const char *)UTF8String
{
	[self finishInitialization];

	return [self UTF8String];
	return self.UTF8String;
}

- (size_t)getCString: (char *)cString_
	   maxLength: (size_t)maxLength
	    encoding: (of_string_encoding_t)encoding
{
	[self finishInitialization];

	return [self cStringWithEncoding: encoding];
}

- (size_t)length
{
	[self finishInitialization];

	return [self length];
	return self.length;
}

- (size_t)UTF8StringLength
{
	[self finishInitialization];

	return [self UTF8StringLength];
	return self.UTF8StringLength;
}

- (size_t)cStringLengthWithEncoding: (of_string_encoding_t)encoding
{
	[self finishInitialization];

	return [self cStringLengthWithEncoding: encoding];

						    range: range];
}

- (OFString *)uppercaseString
{
	[self finishInitialization];

	return [self uppercaseString];
	return self.uppercaseString;
}

- (OFString *)lowercaseString
{
	[self finishInitialization];

	return [self lowercaseString];
	return self.lowercaseString;
}

- (OFString *)capitalizedString
{
	[self finishInitialization];

	return [self capitalizedString];
	return self.capitalizedString;
}

- (OFString *)stringByDeletingLeadingWhitespaces
{
	[self finishInitialization];

	return [self stringByDeletingLeadingWhitespaces];
	return self.stringByDeletingLeadingWhitespaces;
}

- (OFString *)stringByDeletingTrailingWhitespaces
{
	[self finishInitialization];

	return [self stringByDeletingTrailingWhitespaces];
	return self.stringByDeletingTrailingWhitespaces;
}

- (OFString *)stringByDeletingEnclosingWhitespaces
{
	[self finishInitialization];

	return [self stringByDeletingEnclosingWhitespaces];
	return self.stringByDeletingEnclosingWhitespaces;
}

- (bool)hasPrefix: (OFString *)prefix
{
	[self finishInitialization];

	return [self hasPrefix: prefix];

						  options: options];
}

- (OFArray *)pathComponents
{
	[self finishInitialization];

	return [self pathComponents];
	return self.pathComponents;
}

- (OFString *)lastPathComponent
{
	[self finishInitialization];

	return [self lastPathComponent];
	return self.lastPathComponent;
}

- (OFString *)stringByDeletingLastPathComponent
{
	[self finishInitialization];

	return [self stringByDeletingLastPathComponent];
	return self.stringByDeletingLastPathComponent;
}

- (intmax_t)decimalValue
{
	[self finishInitialization];

	return [self decimalValue];
	return self.decimalValue;
}

- (uintmax_t)hexadecimalValue
{
	[self finishInitialization];

	return [self hexadecimalValue];
	return self.hexadecimalValue;
}

- (uintmax_t)octalValue
{
	[self finishInitialization];

	return [self octalValue];
	return self.octalValue;
}

- (float)floatValue
{
	[self finishInitialization];

	return [self floatValue];
	return self.floatValue;
}

- (double)doubleValue
{
	[self finishInitialization];

	return [self doubleValue];
	return self.doubleValue;
}

- (const of_unichar_t *)characters
{
	[self finishInitialization];

	return [self characters];
	return self.characters;
}

- (const of_char16_t *)UTF16String
{
	[self finishInitialization];

	return [self UTF16String];
	return self.UTF16String;
}

- (const of_char16_t *)UTF16StringWithByteOrder: (of_byte_order_t)byteOrder
{
	[self finishInitialization];

	return [self UTF16StringWithByteOrder: byteOrder];
}

- (size_t)UTF16StringLength
{
	[self finishInitialization];

	return [self UTF16StringLength];
	return self.UTF16StringLength;
}

- (const of_char32_t *)UTF32String
{
	[self finishInitialization];

	return [self UTF32String];
	return self.UTF32String;
}

- (const of_char32_t *)UTF32StringWithByteOrder: (of_byte_order_t)byteOrder
{
	[self finishInitialization];

	return [self UTF32StringWithByteOrder: byteOrder];

}

#ifdef OF_HAVE_UNICODE_TABLES
- (OFString *)decomposedStringWithCanonicalMapping
{
	[self finishInitialization];

	return [self decomposedStringWithCanonicalMapping];
	return self.decomposedStringWithCanonicalMapping;
}

- (OFString *)decomposedStringWithCompatibilityMapping
{
	[self finishInitialization];

	return [self decomposedStringWithCompatibilityMapping];
	return self.decomposedStringWithCompatibilityMapping;
}
#endif

#ifdef OF_HAVE_FILES
- (void)writeToFile: (OFString *)path
{
	[self finishInitialization];