ObjFW  Check-in [6772512e3e]

 * \return All elements of the OFDataArray as a C array
 */
- (void*)cArray;

/**
 * Compares the OFDataArray to another object.
 *
 * \param obj An object to compare with
 * \return An integer which is the result of the comparison, see for example
 * \param ary A data array to compare with
 * \return An of_comparsion_result_t
 *	   strcmp
 */
- (int)compare: (id)obj;
- (of_comparison_result_t)compare: (OFDataArray*)obj;

/**
 * Returns a specific item of the OFDataArray.
 *
 * \param index The number of the item to return
 * \return The specified item of the OFDataArray
 */

		return NO;
	if (memcmp([obj cArray], data, count * itemsize))
		return NO;

	return YES;
}

- (int)compare: (id)obj
- (of_comparison_result_t)compare: (OFDataArray*)ary
{
	int ret;
	int cmp;

	if (![obj isKindOfClass: [OFDataArray class]])
	if (![ary isKindOfClass: [OFDataArray class]])
		@throw [OFInvalidArgumentException newWithClass: isa
						       selector: _cmd];
	if ([obj itemsize] != itemsize)
	if ([ary itemsize] != itemsize)
		@throw [OFInvalidArgumentException newWithClass: isa
						       selector: _cmd];

	if ([obj count] == count)
		return memcmp(data, [obj cArray], count * itemsize);
	if ([ary count] == count) {
		if ((cmp = memcmp(data, [ary cArray], count * itemsize)) == 0)

	if (count > [obj count]) {
		if ((ret = memcmp(data, [obj cArray], [obj count] * itemsize)))
			return ret;
			return OF_ORDERED_SAME;

		if (cmp > 0)
		return *(char*)[self itemAtIndex: [obj count]];
	} else {
			return OF_ORDERED_DESCENDING;
		else
		if ((ret = memcmp(data, [obj cArray], count * itemsize)))
			return ret;

			return OF_ORDERED_ASCENDING;
	}
		return *(char*)[obj itemAtIndex: count] * -1;
	}

	if (count > [ary count])
		return OF_ORDERED_DESCENDING;
	else
		return OF_ORDERED_ASCENDING;
}

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

#include <stdint.h>

#import <objc/objc.h>
#ifndef __objc_INCLUDE_GNU
#import <objc/message.h>
#endif

/**
 * A result of a comparison.
 */
typedef enum {
	/// The left object is smaller than the right
	OF_ORDERED_ASCENDING = -1,
	/// Both objects are equal
	OF_ORDERED_SAME = 0,
	/// The left object is bigger than the right
	OF_ORDERED_DESCENDING = 1
} of_comparison_result_t;

/**
 * The OFObject class is the base class for all other classes inside ObjFW.
 */
@interface OFObject
{
	/// The class of the object
	Class isa;

/**
 * \return The length of the string which cString would return
 */
- (size_t)cStringLength;

/**
 * Compares the OFString to another object.
 * Compares the OFString to another OFString.
 *
 * \param obj An object to compare with
 * \return An integer which is the result of the comparison, see for example
 * \param str A string to compare with
 * \return An of_comparison_result_t
 *	   strcmp
 */
- (int)compare: (id)obj;
- (of_comparison_result_t)compare: (OFString*)str;

/**
 * \param index The index of the Unicode character to return
 * \return The Unicode character at the specified index
 */
- (of_unichar_t)characterAtIndex: (size_t)index;

}

- (id)mutableCopy
{
	return [[OFMutableString alloc] initWithString: self];
}

- (int)compare: (id)obj
- (of_comparison_result_t)compare: (OFString*)str
{
	int cmp;

	if (![obj isKindOfClass: [OFString class]])
	if (![str isKindOfClass: [OFString class]])
		@throw [OFInvalidArgumentException newWithClass: isa
						       selector: _cmd];

	if ([str length] == [self length]) {
		if (length != [str cStringLength]) {
			if (length > [str cStringLength])
				return OF_ORDERED_DESCENDING;
			else
				return OF_ORDERED_ASCENDING;
		}
	return strcmp(string, [obj cString]);

		if ((cmp = memcmp(string, [str cString], length)) == 0)
			return OF_ORDERED_SAME;

		if (cmp > 0)
			return OF_ORDERED_DESCENDING;
		else
			return OF_ORDERED_ASCENDING;
	}

	if ([self length] > [str length])
		return OF_ORDERED_DESCENDING;
	else
		return OF_ORDERED_ASCENDING;
}

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

	    [array[1] removeNItems: 1] && ![array[0] isEqual: array[1]])

	TEST(@"-[copy]", (array[1] = [[array[0] copy] autorelease]) &&
	    [array[0] isEqual: array[1]])

	TEST(@"-[compare]", [array[0] compare: array[1]] == 0 &&
	    [array[1] removeNItems: 1] &&
	    [array[0] compare: array[1]] == 0x42 &&
	    [array[1] compare: array[0]] == -0x42)
	    [array[0] compare: array[1]] == OF_ORDERED_DESCENDING &&
	    [array[1] compare: array[0]] == OF_ORDERED_ASCENDING)

	TEST(@"-[hash]", [array[0] hash] == 0xC54621B6)

	TEST(@"-[removeNItems:]", [array[0] removeNItems: 1])

	TEST(@"Building strings",
	    (array[0] = [class dataArrayWithItemSize: 1]) &&

	s[0] = [OFMutableString stringWithString: @"täs€"];
	s[1] = [OFMutableString string];
	s[2] = [[s[0] copy] autorelease];

	TEST(@"-[isEqual:]", [s[0] isEqual: s[2]] &&
	    ![s[0] isEqual: [[[OFObject alloc] init] autorelease]])

	TEST(@"-[compare:]", [s[0] compare: s[2]] == 0 &&
	    [s[0] compare: @""] != 0)
	TEST(@"-[compare:]", [s[0] compare: s[2]] == OF_ORDERED_SAME &&
	    [s[0] compare: @""] != OF_ORDERED_SAME)

	TEST(@"-[hash] is the same if -[isEqual:] is YES",
	    [s[0] hash] == [s[2] hash])

	TEST(@"-[appendString:] and -[appendCString:]",
	    [s[1] appendCString: "1𝄞"] && [s[1] appendString: @"3"] &&
	    [[s[0] appendString: s[1]] isEqual: @"täs€1𝄞3"])