Index: src/Makefile ================================================================== --- src/Makefile +++ src/Makefile @@ -8,10 +8,11 @@ OFExceptions.m \ OFHashes.m \ OFFile.m \ OFList.m \ OFListObject.m \ + OFNumber.m \ OFObject.m \ OFString.m \ OFTCPSocket.m \ OFXMLFactory.m \ ${ASPRINTF} ADDED src/OFNumber.h Index: src/OFNumber.h ================================================================== --- src/OFNumber.h +++ src/OFNumber.h @@ -0,0 +1,147 @@ +/* + * Copyright (c) 2008 + * Jonathan Schleifer + * + * All rights reserved. + * + * This file is part of libobjfw. It may be distributed under the terms of the + * Q Public License 1.0, which can be found in the file LICENSE included in + * the packaging of this file. + */ + +#import "OFObject.h" + +enum of_number_type { + OF_NUMBER_CHAR, + OF_NUMBER_SHORT, + OF_NUMBER_INT, + OF_NUMBER_LONG, + OF_NUMBER_UCHAR, + OF_NUMBER_USHORT, + OF_NUMBER_UINT, + OF_NUMBER_ULONG, + OF_NUMBER_INT8, + OF_NUMBER_INT16, + OF_NUMBER_INT32, + OF_NUMBER_INT64, + OF_NUMBER_UINT8, + OF_NUMBER_UINT16, + OF_NUMBER_UINT32, + OF_NUMBER_UINT64, + OF_NUMBER_SIZE, + OF_NUMBER_SSIZE, + OF_NUMBER_PTRDIFF, + OF_NUMBER_INTPTR, + OF_NUMBER_FLOAT, + OF_NUMBER_DOUBLE, + OF_NUMBER_LONG_DOUBLE +}; + +/** + * The OFNumber class provides a way to store a number in an object and + * manipulate it. + */ +@interface OFNumber: OFObject +{ + union { + char char_; + short short_; + int int_; + long long_; + unsigned char uchar; + unsigned short ushort; + unsigned int uint; + unsigned long ulong; + int8_t int8; + int16_t int16; + int32_t int32; + int64_t int64; + uint8_t uint8; + uint16_t uint16; + uint32_t uint32; + uint64_t uint64; + size_t size; + ssize_t ssize; + ptrdiff_t ptrdiff; + intptr_t intptr; + float float_; + double double_; + long double longdouble; + } value; + enum of_number_type type; +} + ++ newWithChar: (char)char_; ++ newWithShort: (short)short_; ++ newWithInt: (int)int_; ++ newWithLong: (long)long_; ++ newWithUChar: (unsigned char)uchar; ++ newWithUShort: (unsigned short)ushort; ++ newWithUInt: (unsigned int)uint; ++ newWithULong: (unsigned long)ulong; ++ newWithInt8: (int8_t)int8; ++ newWithInt16: (int16_t)int16; ++ newWithInt32: (int32_t)int32; ++ newWithInt64: (int64_t)int64; ++ newWithUInt8: (uint8_t)uint8; ++ newWithUInt16: (uint16_t)uint16; ++ newWithUInt32: (uint32_t)uint32; ++ newWithUInt64: (uint64_t)uint64; ++ newWithSize: (size_t)size; ++ newWithSSize: (ssize_t)ssize; ++ newWithPtrDiff: (ptrdiff_t)ptrdiff; ++ newWithIntPtr: (intptr_t)intptr; ++ newWithFloat: (float)float_; ++ newWithDouble: (double)double_; ++ newWithLongDouble: (long double)longdouble; + +- initWithChar: (char)char_; +- initWithShort: (short)short_; +- initWithInt: (int)int_; +- initWithLong: (long)long_; +- initWithUChar: (unsigned char)uchar; +- initWithUShort: (unsigned short)ushort; +- initWithUInt: (unsigned int)uint; +- initWithULong: (unsigned long)ulong; +- initWithInt8: (int8_t)int8; +- initWithInt16: (int16_t)int16; +- initWithInt32: (int32_t)int32; +- initWithInt64: (int64_t)int64; +- initWithUInt8: (uint8_t)uint8; +- initWithUInt16: (uint16_t)uint16; +- initWithUInt32: (uint32_t)uint32; +- initWithUInt64: (uint64_t)uint64; +- initWithSize: (size_t)size; +- initWithSSize: (ssize_t)ssize; +- initWithPtrDiff: (ptrdiff_t)ptrdiff; +- initWithIntPtr: (intptr_t)intptr; +- initWithFloat: (float)float_; +- initWithDouble: (double)double_; +- initWithLongDouble: (long double)longdouble; + +- (enum of_number_type)type; + +- (char)asChar; +- (short)asShort; +- (int)asInt; +- (long)asLong; +- (unsigned char)asUChar; +- (unsigned short)asUShort; +- (unsigned int)asUInt; +- (unsigned long)asULong; +- (int8_t)asInt8; +- (int16_t)asInt16; +- (int32_t)asInt32; +- (int64_t)asInt64; +- (uint8_t)asUInt8; +- (uint16_t)asUInt16; +- (uint32_t)asUInt32; +- (uint64_t)asUInt64; +- (size_t)asSize; +- (ssize_t)asSSize; +- (ptrdiff_t)asPtrDiff; +- (intptr_t)asIntPtr; +- (float)asFloat; +- (double)asDouble; +- (long double)asLongDouble; +@end ADDED src/OFNumber.m Index: src/OFNumber.m ================================================================== --- src/OFNumber.m +++ src/OFNumber.m @@ -0,0 +1,535 @@ +/* + * Copyright (c) 2008 + * Jonathan Schleifer + * + * All rights reserved. + * + * This file is part of libobjfw. It may be distributed under the terms of the + * Q Public License 1.0, which can be found in the file LICENSE included in + * the packaging of this file. + */ + +#import "OFNumber.h" +#import "OFExceptions.h" + +#define RETURN_AS(t) \ + switch (type) { \ + case OF_NUMBER_CHAR: \ + return (t)value.char_; \ + case OF_NUMBER_SHORT: \ + return (t)value.short_; \ + case OF_NUMBER_INT: \ + return (t)value.int_; \ + case OF_NUMBER_LONG: \ + return (t)value.long_; \ + case OF_NUMBER_UCHAR: \ + return (t)value.uchar; \ + case OF_NUMBER_USHORT: \ + return (t)value.ushort; \ + case OF_NUMBER_UINT: \ + return (t)value.uint; \ + case OF_NUMBER_ULONG: \ + return (t)value.ulong; \ + case OF_NUMBER_INT8: \ + return (t)value.int8; \ + case OF_NUMBER_INT16: \ + return (t)value.int16; \ + case OF_NUMBER_INT32: \ + return (t)value.int32; \ + case OF_NUMBER_INT64: \ + return (t)value.int64; \ + case OF_NUMBER_UINT8: \ + return (t)value.uint8; \ + case OF_NUMBER_UINT16: \ + return (t)value.uint16; \ + case OF_NUMBER_UINT32: \ + return (t)value.uint32; \ + case OF_NUMBER_UINT64: \ + return (t)value.uint64; \ + case OF_NUMBER_SIZE: \ + return (t)value.size; \ + case OF_NUMBER_SSIZE: \ + return (t)value.ssize; \ + case OF_NUMBER_PTRDIFF: \ + return (t)value.ptrdiff; \ + case OF_NUMBER_INTPTR: \ + return (t)value.intptr; \ + case OF_NUMBER_FLOAT: \ + return (t)value.float_; \ + case OF_NUMBER_DOUBLE: \ + return (t)value.double_; \ + case OF_NUMBER_LONG_DOUBLE: \ + return (t)value.longdouble; \ + default: \ + @throw [OFInvalidFormatException newWithObject: self]; \ + \ + /* Make gcc happy */ \ + return 0; \ + } + +@implementation OFNumber ++ newWithChar: (char)char_ +{ + return [[self alloc] initWithChar: char_]; +} + ++ newWithShort: (short)short_ +{ + return [[self alloc] initWithShort: short_]; +} + ++ newWithInt: (int)int_ +{ + return [[self alloc] initWithInt: int_]; +} + ++ newWithLong: (long)long_ +{ + return [[self alloc] initWithLong: long_]; +} + ++ newWithUChar: (unsigned char)uchar +{ + return [[self alloc] initWithUChar: uchar]; +} + ++ newWithUShort: (unsigned short)ushort +{ + return [[self alloc] initWithUShort: ushort]; +} + ++ newWithUInt: (unsigned int)uint +{ + return [[self alloc] initWithUInt: uint]; +} + ++ newWithULong: (unsigned long)ulong +{ + return [[self alloc] initWithULong: ulong]; +} + ++ newWithInt8: (int8_t)int8 +{ + return [[self alloc] initWithInt8: int8]; +} + ++ newWithInt16: (int16_t)int16 +{ + return [[self alloc] initWithInt16: int16]; +} + ++ newWithInt32: (int32_t)int32 +{ + return [[self alloc] initWithInt32: int32]; +} + ++ newWithInt64: (int64_t)int64 +{ + return [[self alloc] initWithInt64: int64]; +} + ++ newWithUInt8: (uint8_t)uint8 +{ + return [[self alloc] initWithUInt8: uint8]; +} + ++ newWithUInt16: (uint16_t)uint16 +{ + return [[self alloc] initWithUInt16: uint16]; +} + ++ newWithUInt32: (uint32_t)uint32 +{ + return [[self alloc] initWithUInt32: uint32]; +} + ++ newWithUInt64: (uint64_t)uint64 +{ + return [[self alloc] initWithUInt64: uint64]; +} + ++ newWithSize: (size_t)size +{ + return [[self alloc] initWithSize: size]; +} + ++ newWithSSize: (ssize_t)ssize +{ + return [[self alloc] initWithSSize: ssize]; +} + ++ newWithPtrDiff: (ptrdiff_t)ptrdiff +{ + return [[self alloc] initWithPtrDiff: ptrdiff]; +} + ++ newWithIntPtr: (intptr_t)intptr +{ + return [[self alloc] initWithIntPtr: intptr]; +} + ++ newWithFloat: (float)float_ +{ + return [[self alloc] initWithFloat: float_]; +} + ++ newWithDouble: (double)double_ +{ + return [[self alloc] initWithDouble: double_]; +} + ++ newWithLongDouble: (long double)longdouble +{ + return [[self alloc] initWithLongDouble: longdouble]; +} + +- initWithChar: (char)char_ +{ + if ((self = [super init])) { + value.char_ = char_; + type = OF_NUMBER_CHAR; + } + + return self; +} + +- initWithShort: (short)short_ +{ + if ((self = [super init])) { + value.short_ = short_; + type = OF_NUMBER_SHORT; + } + + return self; +} + +- initWithInt: (int)int_ +{ + if ((self = [super init])) { + value.int_ = int_; + type = OF_NUMBER_INT; + } + + return self; +} + +- initWithLong: (long)long_ +{ + if ((self = [super init])) { + value.long_ = long_; + type = OF_NUMBER_LONG; + } + + return self; +} + +- initWithUChar: (unsigned char)uchar +{ + if ((self = [super init])) { + value.uchar = uchar; + type = OF_NUMBER_UCHAR; + } + + return self; +} + +- initWithUShort: (unsigned short)ushort +{ + if ((self = [super init])) { + value.ushort = ushort; + type = OF_NUMBER_USHORT; + } + + return self; +} + +- initWithUInt: (unsigned int)uint +{ + if ((self = [super init])) { + value.uint = uint; + type = OF_NUMBER_UINT; + } + + return self; +} + +- initWithULong: (unsigned long)ulong +{ + if ((self = [super init])) { + value.ulong = ulong; + type = OF_NUMBER_ULONG; + } + + return self; +} + +- initWithInt8: (int8_t)int8 +{ + if ((self = [super init])) { + value.int8 = int8; + type = OF_NUMBER_INT8; + } + + return self; +} + +- initWithInt16: (int16_t)int16 +{ + if ((self = [super init])) { + value.int16 = int16; + type = OF_NUMBER_INT16; + } + + return self; +} + +- initWithInt32: (int32_t)int32 +{ + if ((self = [super init])) { + value.int32 = int32; + type = OF_NUMBER_INT32; + } + + return self; +} + +- initWithInt64: (int64_t)int64 +{ + if ((self = [super init])) { + value.int64 = int64; + type = OF_NUMBER_INT64; + } + + return self; +} + +- initWithUInt8: (uint8_t)uint8 +{ + if ((self = [super init])) { + value.uint8 = uint8; + type = OF_NUMBER_UINT8; + } + + return self; +} + +- initWithUInt16: (uint16_t)uint16 +{ + if ((self = [super init])) { + value.uint16 = uint16; + type = OF_NUMBER_UINT16; + } + + return self; +} + +- initWithUInt32: (uint32_t)uint32 +{ + if ((self = [super init])) { + value.uint32 = uint32; + type = OF_NUMBER_UINT32; + } + + return self; +} + +- initWithUInt64: (uint64_t)uint64 +{ + if ((self = [super init])) { + value.uint64 = uint64; + type = OF_NUMBER_UINT64; + } + + return self; +} + +- initWithSize: (size_t)size +{ + if ((self = [super init])) { + value.size = size; + type = OF_NUMBER_SIZE; + } + + return self; +} + +- initWithSSize: (ssize_t)ssize +{ + if ((self = [super init])) { + value.ssize = ssize; + type = OF_NUMBER_SSIZE; + } + + return self; +} + +- initWithPtrDiff: (ptrdiff_t)ptrdiff +{ + if ((self = [super init])) { + value.ptrdiff = ptrdiff; + type = OF_NUMBER_PTRDIFF; + } + + return self; +} + +- initWithIntPtr: (intptr_t)intptr +{ + if ((self = [super init])) { + value.intptr = intptr; + type = OF_NUMBER_INTPTR; + } + + return self; +} + +- initWithFloat: (float)float_ +{ + if ((self = [super init])) { + value.float_ = float_; + type = OF_NUMBER_FLOAT; + } + + return self; +} + +- initWithDouble: (double)double_ +{ + if ((self = [super init])) { + value.double_ = double_; + type = OF_NUMBER_DOUBLE; + } + + return self; +} + +- initWithLongDouble: (long double)longdouble +{ + if ((self = [super init])) { + value.longdouble = longdouble; + type = OF_NUMBER_LONG_DOUBLE; + } + + return self; +} + +- (enum of_number_type)type +{ + return type; +} + +- (char)asChar +{ + RETURN_AS(char) +} + +- (short)asShort +{ + RETURN_AS(short) +} + +- (int)asInt +{ + RETURN_AS(int) +} + +- (long)asLong +{ + RETURN_AS(long) +} + +- (unsigned char)asUChar +{ + RETURN_AS(unsigned char) +} + +- (unsigned short)asUShort +{ + RETURN_AS(unsigned short) +} + +- (unsigned int)asUInt +{ + RETURN_AS(unsigned int) +} + +- (unsigned long)asULong +{ + RETURN_AS(unsigned long) +} + +- (int8_t)asInt8 +{ + RETURN_AS(int8_t) +} + +- (int16_t)asInt16 +{ + RETURN_AS(int16_t) +} + +- (int32_t)asInt32 +{ + RETURN_AS(int32_t) +} + +- (int64_t)asInt64 +{ + RETURN_AS(int64_t) +} + +- (uint8_t)asUInt8 +{ + RETURN_AS(uint8_t) +} + +- (uint16_t)asUInt16 +{ + RETURN_AS(uint16_t) +} + +- (uint32_t)asUInt32 +{ + RETURN_AS(uint32_t) +} + +- (uint64_t)asUInt64 +{ + RETURN_AS(uint64_t) +} + +- (size_t)asSize +{ + RETURN_AS(size_t) +} + +- (ssize_t)asSSize +{ + RETURN_AS(ssize_t) +} + +- (ptrdiff_t)asPtrDiff +{ + RETURN_AS(ptrdiff_t) +} + +- (intptr_t)asIntPtr +{ + RETURN_AS(intptr_t) +} + +- (float)asFloat +{ + RETURN_AS(float) +} + +- (double)asDouble +{ + RETURN_AS(double) +} + +- (long double)asLongDouble +{ + RETURN_AS(long double) +} +@end Index: src/OFString.h ================================================================== --- src/OFString.h +++ src/OFString.h @@ -107,11 +107,11 @@ * Frees the OFString and sets it to the specified OFString. * * \param str An OFString to set the OFString to. * \return The new OFString */ -- (OFString*)setTo: (OFString*)str; +- setTo: (OFString*)str; /** * Compares the OFString to another OFString. * * \param str An OFString to compare with Index: src/OFString.m ================================================================== --- src/OFString.m +++ src/OFString.m @@ -225,11 +225,11 @@ - (OFString*)clone { return [OFString newFromCString: string]; } -- (OFString*)setTo: (OFString*)str +- setTo: (OFString*)str { [self free]; return (self = [str clone]); }