OFString.h

Go to the documentation of this file.

/*
 * Copyright (c) 2008-2025 Jonathan Schleifer <js@nil.im>
 *
 * All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License version 3.0 only,
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
 * version 3.0 for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3.0 along with this program. If not, see
 * <https://www.gnu.org/licenses/>.
 */
 
#ifndef __STDC_LIMIT_MACROS
# define __STDC_LIMIT_MACROS
#endif
#ifndef __STDC_CONSTANT_MACROS
# define __STDC_CONSTANT_MACROS
#endif
 
#include "objfw-defs.h"
 
#ifdef OF_HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif
 
#include <stdarg.h>
#include <stdint.h>
#ifdef OF_HAVE_INTTYPES_H
# include <inttypes.h>
#endif
 
#import "OFObject.h"
#import "OFJSONRepresentation.h"
#import "OFMessagePackRepresentation.h"
 
OF_ASSUME_NONNULL_BEGIN
 
@class OFArray OF_GENERIC(ObjectType);
@class OFCharacterSet;
@class OFConstantString;
@class OFIRI;
@class OFString;
 
#if defined(__cplusplus) && __cplusplus >= 201103L
typedef char16_t OFChar16;
typedef char32_t OFChar32;
#else
typedef uint_least16_t OFChar16;
typedef uint_least32_t OFChar32;
#endif
typedef OFChar32 OFUnichar;
 
typedef enum {
    /*
     * UTF-8 *has* to be 0, so that if the current @ref OFLocale is
     * `nil`, `[OFLocale encoding]` returns UTF-8.
     */
    OFStringEncodingUTF8,
    OFStringEncodingASCII,
    OFStringEncodingISO8859_1,
    OFStringEncodingISO8859_2,
    OFStringEncodingISO8859_3,
    OFStringEncodingISO8859_15,
    OFStringEncodingWindows1251,
    OFStringEncodingWindows1252,
    OFStringEncodingCodepage437,
    OFStringEncodingCodepage850,
    OFStringEncodingCodepage858,
    OFStringEncodingMacRoman,
    OFStringEncodingKOI8R,
    OFStringEncodingKOI8U,
    OFStringEncodingWindows1250,
    OFStringEncodingCodepage852,
    OFStringEncodingAutodetect = -1
} OFStringEncoding;
 
typedef enum {
    OFStringSearchBackwards = 1
} OFStringSearchOptions;
 
typedef enum {
    OFStringSkipEmptyComponents = 1
} OFStringSeparationOptions;
 
#ifdef OF_HAVE_BLOCKS
typedef void (^OFStringLineEnumerationBlock)(OFString *line, bool *stop);
#endif
 
@interface OFString: OFObject <OFCopying, OFMutableCopying, OFComparing,
    OFJSONRepresentation, OFMessagePackRepresentation>
@property (readonly, nonatomic) size_t length;
 
@property (readonly, nonatomic) const char *UTF8String;
 
@property (readonly, nonatomic) size_t UTF8StringLength;
 
@property (readonly, nonatomic) OFString *uppercaseString;
 
@property (readonly, nonatomic) OFString *lowercaseString;
 
@property (readonly, nonatomic) OFString *capitalizedString;
 
@property (readonly, nonatomic) signed char charValue;
 
@property (readonly, nonatomic) short shortValue;
 
@property (readonly, nonatomic) int intValue;
 
@property (readonly, nonatomic) long longValue;
 
@property (readonly, nonatomic) long long longLongValue;
 
@property (readonly, nonatomic) unsigned char unsignedCharValue;
 
@property (readonly, nonatomic) unsigned short unsignedShortValue;
 
@property (readonly, nonatomic) unsigned int unsignedIntValue;
 
@property (readonly, nonatomic) unsigned long unsignedLongValue;
 
@property (readonly, nonatomic) unsigned long long unsignedLongLongValue;
 
@property (readonly, nonatomic) float floatValue;
 
@property (readonly, nonatomic) double doubleValue;
 
@property (readonly, nonatomic) const OFUnichar *characters;
 
@property (readonly, nonatomic) const OFChar16 *UTF16String;
 
@property (readonly, nonatomic) size_t UTF16StringLength;
 
@property (readonly, nonatomic) const OFChar32 *UTF32String;
 
@property (readonly, nonatomic) OFString *stringByDeletingLeadingWhitespaces;
 
@property (readonly, nonatomic) OFString *stringByDeletingTrailingWhitespaces;
 
@property (readonly, nonatomic) OFString *stringByDeletingEnclosingWhitespaces;
 
#if defined(OF_WINDOWS) || defined(DOXYGEN)
@property (readonly, nonatomic)
    OFString *stringByExpandingWindowsEnvironmentStrings;
#endif
 
+ (instancetype)string;
 
+ (instancetype)stringWithUTF8String: (const char *)UTF8String;
 
+ (instancetype)stringWithUTF8String: (const char *)UTF8String
                  length: (size_t)UTF8StringLength;
 
+ (instancetype)stringWithUTF8StringNoCopy: (char *)UTF8String
                  freeWhenDone: (bool)freeWhenDone;
 
+ (instancetype)stringWithUTF8StringNoCopy: (char *)UTF8String
                    length: (size_t)UTF8StringLength
                  freeWhenDone: (bool)freeWhenDone;
 
+ (instancetype)stringWithCString: (const char *)cString
             encoding: (OFStringEncoding)encoding;
 
+ (instancetype)stringWithCString: (const char *)cString
             encoding: (OFStringEncoding)encoding
               length: (size_t)cStringLength;
 
+ (instancetype)stringWithData: (OFData *)data
              encoding: (OFStringEncoding)encoding;
 
+ (instancetype)stringWithString: (OFString *)string;
 
+ (instancetype)stringWithCharacters: (const OFUnichar *)characters
                  length: (size_t)length;
 
+ (instancetype)stringWithUTF16String: (const OFChar16 *)string;
 
+ (instancetype)stringWithUTF16String: (const OFChar16 *)string
                   length: (size_t)length;
 
+ (instancetype)stringWithUTF16String: (const OFChar16 *)string
                byteOrder: (OFByteOrder)byteOrder;
 
+ (instancetype)stringWithUTF16String: (const OFChar16 *)string
                   length: (size_t)length
                byteOrder: (OFByteOrder)byteOrder;
 
+ (instancetype)stringWithUTF32String: (const OFChar32 *)string;
 
+ (instancetype)stringWithUTF32String: (const OFChar32 *)string
                   length: (size_t)length;
 
+ (instancetype)stringWithUTF32String: (const OFChar32 *)string
                byteOrder: (OFByteOrder)byteOrder;
 
+ (instancetype)stringWithUTF32String: (const OFChar32 *)string
                   length: (size_t)length
                byteOrder: (OFByteOrder)byteOrder;
 
+ (instancetype)stringWithFormat: (OFConstantString *)format, ...;
 
#ifdef OF_HAVE_FILES
+ (instancetype)stringWithContentsOfFile: (OFString *)path;
 
+ (instancetype)stringWithContentsOfFile: (OFString *)path
                encoding: (OFStringEncoding)encoding;
#endif
 
+ (instancetype)stringWithContentsOfIRI: (OFIRI *)IRI;
 
+ (instancetype)stringWithContentsOfIRI: (OFIRI *)IRI
                   encoding: (OFStringEncoding)encoding;
 
- (instancetype)init OF_DESIGNATED_INITIALIZER;
 
- (instancetype)initWithUTF8String: (const char *)UTF8String;
 
- (instancetype)initWithUTF8String: (const char *)UTF8String
                length: (size_t)UTF8StringLength;
 
- (instancetype)initWithUTF8StringNoCopy: (char *)UTF8String
                freeWhenDone: (bool)freeWhenDone;
 
- (instancetype)initWithUTF8StringNoCopy: (char *)UTF8String
                  length: (size_t)UTF8StringLength
                freeWhenDone: (bool)freeWhenDone;
 
- (instancetype)initWithCString: (const char *)cString
               encoding: (OFStringEncoding)encoding;
 
- (instancetype)initWithCString: (const char *)cString
               encoding: (OFStringEncoding)encoding
             length: (size_t)cStringLength;
 
- (instancetype)initWithData: (OFData *)data
            encoding: (OFStringEncoding)encoding;
 
- (instancetype)initWithString: (OFString *)string;
 
- (instancetype)initWithCharacters: (const OFUnichar *)characters
                length: (size_t)length;
 
- (instancetype)initWithUTF16String: (const OFChar16 *)string;
 
- (instancetype)initWithUTF16String: (const OFChar16 *)string
                 length: (size_t)length;
 
- (instancetype)initWithUTF16String: (const OFChar16 *)string
              byteOrder: (OFByteOrder)byteOrder;
 
- (instancetype)initWithUTF16String: (const OFChar16 *)string
                 length: (size_t)length
              byteOrder: (OFByteOrder)byteOrder;
 
- (instancetype)initWithUTF32String: (const OFChar32 *)string;
 
- (instancetype)initWithUTF32String: (const OFChar32 *)string
                 length: (size_t)length;
 
- (instancetype)initWithUTF32String: (const OFChar32 *)string
              byteOrder: (OFByteOrder)byteOrder;
 
- (instancetype)initWithUTF32String: (const OFChar32 *)string
                 length: (size_t)length
              byteOrder: (OFByteOrder)byteOrder;
 
- (instancetype)initWithFormat: (OFConstantString *)format, ...;
 
- (instancetype)initWithFormat: (OFConstantString *)format
             arguments: (va_list)arguments;
 
#ifdef OF_HAVE_FILES
- (instancetype)initWithContentsOfFile: (OFString *)path;
 
- (instancetype)initWithContentsOfFile: (OFString *)path
                  encoding: (OFStringEncoding)encoding;
#endif
 
- (instancetype)initWithContentsOfIRI: (OFIRI *)IRI;
 
- (instancetype)initWithContentsOfIRI: (OFIRI *)IRI
                 encoding: (OFStringEncoding)encoding;
 
- (size_t)getCString: (char *)cString
       maxLength: (size_t)maxLength
        encoding: (OFStringEncoding)encoding;
 
- (size_t)getLossyCString: (char *)cString
        maxLength: (size_t)maxLength
         encoding: (OFStringEncoding)encoding;
 
- (const char *)cStringWithEncoding: (OFStringEncoding)encoding;
 
- (const char *)lossyCStringWithEncoding: (OFStringEncoding)encoding;
 
- (const char *)insecureCStringWithEncoding: (OFStringEncoding)encoding;
 
- (size_t)cStringLengthWithEncoding: (OFStringEncoding)encoding;
 
- (OFComparisonResult)compare: (OFString *)string;
 
- (OFComparisonResult)caseInsensitiveCompare: (OFString *)string;
 
- (OFUnichar)characterAtIndex: (size_t)index;
 
- (void)getCharacters: (OFUnichar *)buffer inRange: (OFRange)range;
 
- (OFRange)rangeOfString: (OFString *)string;
 
- (OFRange)rangeOfString: (OFString *)string
         options: (OFStringSearchOptions)options;
 
- (OFRange)rangeOfString: (OFString *)string
         options: (OFStringSearchOptions)options
           range: (OFRange)range;
 
- (OFRange)rangeOfCharacterFromSet: (OFCharacterSet *)characterSet;
 
- (OFRange)rangeOfCharacterFromSet: (OFCharacterSet *)characterSet
               options: (OFStringSearchOptions)options;
 
- (OFRange)rangeOfCharacterFromSet: (OFCharacterSet *)characterSet
               options: (OFStringSearchOptions)options
                 range: (OFRange)range;
 
- (size_t)indexOfCharacterFromSet: (OFCharacterSet *)characterSet
    OF_DEPRECATED(ObjFW, 1, 3, "Use -[rangeOfCharacterFromSet:] instead");
 
- (size_t)indexOfCharacterFromSet: (OFCharacterSet *)characterSet
              options: (OFStringSearchOptions)options
    OF_DEPRECATED(ObjFW, 1, 3,
    "Use -[rangeOfCharacterFromSet:options:] instead");
 
- (size_t)indexOfCharacterFromSet: (OFCharacterSet *)characterSet
              options: (OFStringSearchOptions)options
                range: (OFRange)range
    OF_DEPRECATED(ObjFW, 1, 3,
    "Use -[rangeOfCharacterFromSet:options:range:] instead");
 
- (bool)containsString: (OFString *)string;
 
- (OFString *)substringFromIndex: (size_t)idx;
 
- (OFString *)substringToIndex: (size_t)idx;
 
- (OFString *)substringWithRange: (OFRange)range;
 
- (signed char)charValueWithBase: (unsigned char)base;
 
- (short)shortValueWithBase: (unsigned char)base;
 
- (int)intValueWithBase: (unsigned char)base;
 
- (long)longValueWithBase: (unsigned char)base;
 
- (long long)longLongValueWithBase: (unsigned char)base;
 
- (unsigned char)unsignedCharValueWithBase: (unsigned char)base;
 
- (unsigned short)unsignedShortValueWithBase: (unsigned char)base;
 
- (unsigned int)unsignedIntValueWithBase: (unsigned char)base;
 
- (unsigned long)unsignedLongValueWithBase: (unsigned char)base;
 
- (unsigned long long)unsignedLongLongValueWithBase: (unsigned char)base;
 
- (OFString *)stringByAppendingString: (OFString *)string;
 
- (OFString *)stringByAppendingFormat: (OFConstantString *)format, ...;
 
- (OFString *)stringByAppendingFormat: (OFConstantString *)format
                arguments: (va_list)arguments;
 
- (OFString *)stringByReplacingOccurrencesOfString: (OFString *)string
                    withString: (OFString *)replacement;
 
- (OFString *)stringByReplacingOccurrencesOfString: (OFString *)string
                    withString: (OFString *)replacement
                       options: (int)options
                         range: (OFRange)range;
 
- (bool)hasPrefix: (OFString *)prefix;
 
- (bool)hasSuffix: (OFString *)suffix;
 
- (OFArray OF_GENERIC(OFString *) *)
    componentsSeparatedByString: (OFString *)delimiter;
 
- (OFArray OF_GENERIC(OFString *) *)
    componentsSeparatedByString: (OFString *)delimiter
            options: (OFStringSeparationOptions)options;
 
- (OFArray OF_GENERIC(OFString *) *)
    componentsSeparatedByCharactersInSet: (OFCharacterSet *)characterSet;
 
- (OFArray OF_GENERIC(OFString *) *)
    componentsSeparatedByCharactersInSet: (OFCharacterSet *)characterSet
                 options: (OFStringSeparationOptions)options;
 
- (const OFChar16 *)UTF16StringWithByteOrder: (OFByteOrder)byteOrder;
 
- (const OFChar32 *)UTF32StringWithByteOrder: (OFByteOrder)byteOrder;
 
- (OFData *)dataWithEncoding: (OFStringEncoding)encoding;
 
#ifdef OF_HAVE_FILES
- (void)writeToFile: (OFString *)path;
 
- (void)writeToFile: (OFString *)path encoding: (OFStringEncoding)encoding;
#endif
 
- (void)writeToIRI: (OFIRI *)IRI;
 
- (void)writeToIRI: (OFIRI *)IRI encoding: (OFStringEncoding)encoding;
 
#ifdef OF_HAVE_BLOCKS
- (void)enumerateLinesUsingBlock: (OFStringLineEnumerationBlock)block;
#endif
@end
 
#ifdef __cplusplus
extern "C" {
#endif
extern OFStringEncoding OFStringEncodingParseName(OFString *name);
 
extern OFString *_Nullable OFStringEncodingName(OFStringEncoding encoding);
 
extern size_t OFUTF16StringLength(const OFChar16 *string);
 
extern size_t OFUTF32StringLength(const OFChar32 *string);
#ifdef __cplusplus
}
#endif
 
OF_ASSUME_NONNULL_END
 
#import "OFConstantString.h"
#import "OFMutableString.h"
#import "OFString+CryptographicHashing.h"
#import "OFString+JSONParsing.h"
#ifdef OF_HAVE_FILES
# import "OFString+PathAdditions.h"
#endif
#import "OFString+PercentEncoding.h"
#import "OFString+PropertyListParsing.h"
#import "OFString+XMLEscaping.h"
#import "OFString+XMLUnescaping.h"
 
#if !defined(NSINTEGER_DEFINED) && !__has_feature(modules)
/*
 * Very *ugly* hack required for string boxing literals to work.
 *
 * This hack is needed in order to work with `@class NSString` from Apple's
 * objc/NSString.h - which is included when using modules - as
 * @compatibility_alias does not work if @class has been used before.
 * For some reason, this makes Clang refer to OFString for string box literals
 * and not to NSString (which would result in a linker error, but would be the
 * correct behavior).
 *
 * TODO: Submit a patch for Clang that makes the boxing classes configurable!
 */
@interface NSString: OFString
@end
#endif