ObjFW  Check-in [f38744df74]

 *
 * \return The objects of the array as a C array
 */
- (id*)objects;

/**
 * \brief Returns the index of the first object that is equivalent to the
 *	  specified object or OF_INVALID_INDEX if it was not found.
 *	  specified object or OF_NOT_FOUND if it was not found.
 *
 * \param object The object whose index is returned
 * \return The index of the first object equivalent to the specified object
 *	   or OF_INVALID_INDEX if it was not found
 *	   or OF_NOT_FOUND if it was not found
 */
- (size_t)indexOfObject: (id)object;

/**
 * \brief Returns the index of the first object that has the same address as the
 *	  specified object or OF_INVALID_INDEX if it was not found.
 *	  specified object or OF_NOT_FOUND if it was not found.
 *
 * \param object The object whose index is returned
 * \return The index of the first object that has the same aaddress as
 *	   the specified object or OF_INVALID_INDEX if it was not found
 *	   the specified object or OF_NOT_FOUND if it was not found
 */
- (size_t)indexOfObjectIdenticalTo: (id)object;

/**
 * \brief Checks whether the array contains an object with the specified
 *	  address.
 *

{
	size_t i, count = [self count];

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

	return OF_INVALID_INDEX;
	return OF_NOT_FOUND;
}

- (size_t)indexOfObjectIdenticalTo: (id)object
{
	size_t i, count = [self count];

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

	return OF_INVALID_INDEX;
	return OF_NOT_FOUND;
}

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

- (BOOL)containsObjectIdenticalTo: (id)object
{
	return ([self indexOfObjectIdenticalTo: object] != OF_INVALID_INDEX);
	return ([self indexOfObjectIdenticalTo: object] != OF_NOT_FOUND);
}

- (id)firstObject
{
	if ([self count] > 0)
		return [self objectAtIndex: 0];

	id *objects = [array cArray];
	size_t i, count = [array count];

	for (i = 0; i < count; i++)
		if ([objects[i] isEqual: object])
			return i;

	return OF_INVALID_INDEX;
	return OF_NOT_FOUND;
}

- (size_t)indexOfObjectIdenticalTo: (id)object
{
	id *objects = [array cArray];
	size_t i, count = [array count];

	for (i = 0; i < count; i++)
		if (objects[i] == object)
			return i;

	return OF_INVALID_INDEX;
	return OF_NOT_FOUND;
}


- (OFArray*)objectsInRange: (of_range_t)range
{
	size_t count;

}

- (size_t)indexOfObject: (id)object
{
	size_t index = [array indexOfObject: object];

	if (index < range.location)
		return OF_INVALID_INDEX;
		return OF_NOT_FOUND;

	index -= range.location;

	if (index >= range.length)
		return OF_INVALID_INDEX;
		return OF_NOT_FOUND;

	return index;
}

- (size_t)indexOfObjectIdenticalTo: (id)object
{
	size_t index = [array indexOfObjectIdenticalTo: object];

	if (index < range.location)
		return OF_INVALID_INDEX;
		return OF_NOT_FOUND;

	index -= range.location;

	if (index >= range.length)
		return OF_INVALID_INDEX;
		return OF_NOT_FOUND;

	return index;
}

- (OFArray*)objectsInRange: (of_range_t)range_
{
	if (range_.location + range_.length > range.length)

					line = [sock readLine];
				} @catch (OFInvalidEncodingException *e) {
					@throw [OFInvalidServerReplyException
					    exceptionWithClass: [self class]];
				}

				range = [line rangeOfString: @";"];
				if (range.location != OF_INVALID_INDEX)
				if (range.location != OF_NOT_FOUND)
					line = [line substringWithRange:
					    of_range(0, range.location)];

				@try {
					toRead =
					    (size_t)[line hexadecimalValue];
				} @catch (OFInvalidFormatException *e) {

# define OF_WEAK_UNAVAILABLE
# define __unsafe_unretained
# define __bridge
# define __autoreleasing
#endif

#define OF_RETAIN_COUNT_MAX UINT_MAX
#define OF_INVALID_INDEX SIZE_MAX
#define OF_NOT_FOUND SIZE_MAX

/**
 * \brief A result of a comparison.
 */
typedef enum of_comparison_result_t {
	/// The left object is smaller than the right
	OF_ORDERED_ASCENDING = -1,

	      inRange: (of_range_t)range;

/**
 * \brief Returns the range of the first occurrence of the string.
 *
 * \param string The string to search
 * \return The range of the first occurrence of the string or a range with
 *	   OF_INVALID_INDEX as start position if it was not found
 *	   OF_NOT_FOUND as start position if it was not found
 */
- (of_range_t)rangeOfString: (OFString*)string;

/**
 * \brief Returns the range of the string.
 *
 * \param string The string to search
 * \param options Options modifying search behaviour
 * \return The range of the first occurrence of the string or a range with
 *	   OF_INVALID_INDEX as start position if it was not found
 *	   OF_NOT_FOUND as start position if it was not found
 */
- (of_range_t)rangeOfString: (OFString*)string
		    options: (of_string_search_options_t)options;

/**
 * \brief Returns the range of the string in the specified range.
 *
 * \param string The string to search
 * \param options Options modifying search behaviour
 * \param range The range in which to search
 * \return The range of the first occurrence of the string or a range with
 *	   OF_INVALID_INDEX as start position if it was not found
 *	   OF_NOT_FOUND as start position if it was not found
 */
- (of_range_t)rangeOfString: (OFString*)string
		    options: (of_string_search_options_t)options
		      range: (of_range_t)range;

/**
 * \brief Returns whether the string contains the specified string.

	of_unichar_t *unicodeString;
	size_t i, searchLength;

	if ((searchLength = [string length]) == 0)
		return of_range(0, 0);

	if (searchLength > range.length)
		return of_range(OF_INVALID_INDEX, 0);
		return of_range(OF_NOT_FOUND, 0);

	if (range.length > SIZE_MAX / sizeof(of_unichar_t))
		@throw [OFOutOfRangeException exceptionWithClass: [self class]];

	pool = objc_autoreleasePoolPush();

	searchString = [string unicodeString];

		}
	} @finally {
		free(unicodeString);
	}

	objc_autoreleasePoolPop(pool);

	return of_range(OF_INVALID_INDEX, 0);
	return of_range(OF_NOT_FOUND, 0);
}

- (BOOL)containsString: (OFString*)string
{
	void *pool;
	const of_unichar_t *unicodeString, *searchString;
	size_t i, length, searchLength;

of_string_utf8_get_position(const char *string, size_t index, size_t length)
{
	size_t i;

	for (i = 0; i <= index; i++)
		if OF_UNLIKELY ((string[i] & 0xC0) == 0x80)
			if (++index > length)
				return OF_INVALID_INDEX;
				return OF_NOT_FOUND;

	return index;
}

@implementation OFString_UTF8
- init
{

	}

	if (cStringLength == 0)
		return of_range(0, 0);

	if (cStringLength > rangeLength ||
	    rangeStart + rangeLength > s->cStringLength)
		return of_range(OF_INVALID_INDEX, 0);
		return of_range(OF_NOT_FOUND, 0);

	if (options & OF_STRING_SEARCH_BACKWARDS) {
		for (i = rangeLength - cStringLength;; i--) {
			if (!memcmp(s->cString + rangeStart + i, cString,
			    cStringLength)) {
				range.location += of_string_utf8_get_index(
				    s->cString + rangeStart, i);
				range.length = [string length];

				return range;
			}

			/* Did not match and we're at the last char */
			if (i == 0)
				return of_range(OF_INVALID_INDEX, 0);
				return of_range(OF_NOT_FOUND, 0);
		}
	} else {
		for (i = 0; i <= rangeLength - cStringLength; i++) {
			if (!memcmp(s->cString + rangeStart + i, cString,
			    cStringLength)) {
				range.location += of_string_utf8_get_index(
				    s->cString + rangeStart, i);
				range.length = [string length];

				return range;
			}
		}
	}

	return of_range(OF_INVALID_INDEX, 0);
	return of_range(OF_NOT_FOUND, 0);
}

- (BOOL)containsString: (OFString*)string
{
	const char *cString = [string UTF8String];
	size_t i, cStringLength = [string UTF8StringLength];

	    R(([s[0] appendFormat: @"%02X", 15])) &&
	    [s[0] isEqual: @"test:1230F"])

	TEST(@"-[rangeOfString:]",
	    [@"𝄞öö" rangeOfString: @"öö"].location == 1 &&
	    [@"𝄞öö" rangeOfString: @"ö"].location == 1 &&
	    [@"𝄞öö" rangeOfString: @"𝄞"].location == 0 &&
	    [@"𝄞öö" rangeOfString: @"x"].location == OF_INVALID_INDEX &&
	    [@"𝄞öö" rangeOfString: @"x"].location == OF_NOT_FOUND &&
	    [@"𝄞öö" rangeOfString: @"öö"
			  options: OF_STRING_SEARCH_BACKWARDS].location == 1 &&
	    [@"𝄞öö" rangeOfString: @"ö"
			  options: OF_STRING_SEARCH_BACKWARDS].location == 2 &&
	    [@"𝄞öö" rangeOfString: @"𝄞"
			  options: OF_STRING_SEARCH_BACKWARDS].location == 0 &&
	    [@"𝄞öö" rangeOfString: @"x"
			  options: OF_STRING_SEARCH_BACKWARDS].location ==
	     OF_INVALID_INDEX)
	     OF_NOT_FOUND)

	TEST(@"-[substringWithRange:]",
	    [[@"𝄞öö" substringWithRange: of_range(1, 1)] isEqual: @"ö"] &&
	    [[@"𝄞öö" substringWithRange: of_range(3, 0)] isEqual: @""])

	EXPECT_EXCEPTION(@"Detect out of range in -[substringWithRange:] #1",
	    OFOutOfRangeException, [@"𝄞öö" substringWithRange: of_range(2, 2)])