ObjFW  Check-in [49859c2bcc]

Overview
Comment:Add getMemForNItems:withSize: & resizeMem:toNItems:withSize: in OFObject

Additionally, interface for OFArray.

Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA3-256: 49859c2bcce1d3706d1ec986571dba48d6892da8a497ecd544fc859ec00d146b
User & Date: js on 2008-10-29 17:29:49
Other Links: manifest | tags
Context
2008-10-30
00:49
Store initialization parameters of exceptions. check-in: ea3b6ef066 user: js tags: trunk
2008-10-29
17:29
Add getMemForNItems:withSize: & resizeMem:toNItems:withSize: in OFObject check-in: 49859c2bcc user: js tags: trunk
16:37
Add OF_NOT_IMPLEMENTED macro. check-in: d6a3d8a5db user: js tags: trunk
Changes
Hide Diffs Unified Diffs Ignore Whitespace Patch

Modified src/Makefile from [4d6994e0b2] to [b348bda782]. 

1
2
3
4

5
6
7
8
9
10
11
12

LIB = ${LIB_PREFIX}objfw${LIB_SUFFIX}
LIB_MAJOR = 1
LIB_MINOR = 0


SRCS = OFConstCString.m		\
       OFCString.m		\
       OFConstWideCString.m	\
       OFExceptions.m		\
       OFHashes.m		\
       OFFile.m			\
       OFList.m			\
       OFListObject.m		\





>
|








1
2
3
4
5
6
7
8
9
10
11
12
13

LIB = ${LIB_PREFIX}objfw${LIB_SUFFIX}
LIB_MAJOR = 1
LIB_MINOR = 0

SRCS = OFArray.m		\
       OFConstCString.m		\
       OFCString.m		\
       OFConstWideCString.m	\
       OFExceptions.m		\
       OFHashes.m		\
       OFFile.m			\
       OFList.m			\
       OFListObject.m		\
︙︙

Added src/OFArray.h version [e463fcbc2b]. 

































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

/*
 * Copyright (c) 2008
 *   Jonathan Schleifer <js@webkeks.org>
 *
 * 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 <stddef.h>

#import "OFObject.h"

@interface OFArray: OFObject
{
	void   *data;
	size_t itemsize;
	size_t size;
}

- initWithItemSize: (size_t)is;
- (size_t)size;
- (void*)item: (size_t)item;
- (void*)last;
- add: (void*)item;
- addNItems: (size_t)nitems
    fromCArray: (void*)carray;
- removeLastNItems: (size_t)nitems;
@end

Added src/OFArray.m version [4b7e261931]. 













































































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

/*
 * Copyright (c) 2008
 *   Jonathan Schleifer <js@webkeks.org>
 *
 * 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 "OFArray.h"

#import "OFExceptions.h"
#import "OFMacros.h"

@implementation OFArray
- initWithItemSize: (size_t)is
{
	if ((self = [super init])) {
		data = NULL;
		itemsize = is;
		size = 0;
	}

	return self;
}

- (size_t)size
{
	return size;
}

- (size_t)itemsize
{
	return itemsize;
}

- (void*)item: (size_t)item
{
	/* FIXME */
	OF_NOT_IMPLEMENTED(NULL)
}

- (void*)last
{
	/* FIXME */
	OF_NOT_IMPLEMENTED(NULL)
}

- add: (void*)item
{
	/* FIXME */
	OF_NOT_IMPLEMENTED(self)
}

- addNItems: (size_t)nitems
 fromCArray: (void*)carray
{
	/* FIXME */
	OF_NOT_IMPLEMENTED(self)
}

- removeLastNItems: (size_t)nitems
{
	/* FIXME */
	OF_NOT_IMPLEMENTED(self)
}
@end

Modified src/OFFile.m from [d80678a165] to [b1dd678aec].

︙︙
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

120
121
122
123
124
125
126


	return ret;
}

- (uint8_t*)readWithSize: (size_t)size
	       andNItems: (size_t)nitems
{
	size_t	memsize;
	uint8_t	*ret;

	memsize = nitems * size;
       
	if (size > SIZE_MAX / nitems) {
		[[OFOverflowException newWithObject: self] raise];
		return NULL;
	}
	
	ret = [self getMemWithSize: memsize];


	@try {
		[self readIntoBuffer: ret
			    withSize: size
			   andNItems: nitems];
	} @catch (OFReadFailedException *e) {
		[self freeMem: ret];








<


<
<
<
<
<
<
<
|
>








102
103
104
105
106
107
108

109
110







111
112
113
114
115
116
117
118
119


	return ret;
}

- (uint8_t*)readWithSize: (size_t)size
	       andNItems: (size_t)nitems
{

	uint8_t	*ret;








	ret = [self getMemForNItems: nitems
			   withSize: size];

	@try {
		[self readIntoBuffer: ret
			    withSize: size
			   andNItems: nitems];
	} @catch (OFReadFailedException *e) {
		[self freeMem: ret];
︙︙

Modified src/OFObject.h from [1168f25909] to [05ff92829e].

︙︙
20
21
22
23
24
25
26


27
28



29
30
31

@interface OFObject: Object
{
	struct __ofobject_allocated_mem *__mem_pool;
}

- init;
- (void*)getMemWithSize: (size_t)size;


- (void*)resizeMem: (void*)ptr
	    toSize: (size_t)size;



- freeMem: (void*)ptr;
- free;
@end








>
>


>
>
>




20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

@interface OFObject: Object
{
	struct __ofobject_allocated_mem *__mem_pool;
}

- init;
- (void*)getMemWithSize: (size_t)size;
- (void*)getMemForNItems: (size_t)nitems
		withSize: (size_t)size;
- (void*)resizeMem: (void*)ptr
	    toSize: (size_t)size;
- (void*)resizeMem: (void*)ptr
	  toNItems: (size_t)nitems
	    ofSize: (size_t)size;
- freeMem: (void*)ptr;
- free;
@end

Modified src/OFObject.m from [fdc15c6565] to [504a3629c1].

︙︙
70
71
72
73
74
75
76














77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
















100
101
102
103
104
105
106

	if (__mem_pool != NULL)
		__mem_pool->next = iter;

	__mem_pool = iter;

	return iter->ptr;
}















- (void*)resizeMem: (void*)ptr
	    toSize: (size_t)size
{
	struct __ofobject_allocated_mem *iter;

	for (iter = __mem_pool; iter != NULL; iter = iter->prev) {
		if (iter->ptr == ptr) {
			if ((ptr = realloc(iter->ptr, size)) == NULL) {
				[[OFNoMemException newWithObject: self
							 andSize: size] raise];
				return NULL;
			}
			
			iter->ptr = ptr;
			return ptr;
		}
	}

	[[OFMemNotPartOfObjException newWithObject: self
					andPointer: ptr] raise];
	return NULL;
}

















- freeMem: (void*)ptr;
{
	struct __ofobject_allocated_mem *iter;

	for (iter = __mem_pool; iter != NULL; iter = iter->prev) {
		if (iter->ptr == ptr) {








>
>
>
>
>
>
>
>
>
>
>
>
>
>











|











>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>








70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

	if (__mem_pool != NULL)
		__mem_pool->next = iter;

	__mem_pool = iter;

	return iter->ptr;
}

- (void*)getMemForNItems: (size_t)nitems
		withSize: (size_t)size
{
	size_t memsize;

	if (size > SIZE_MAX / nitems) {
		[[OFOverflowException newWithObject: self] raise];
		return NULL;
	}

	memsize = nitems * size;
	return [self getMemWithSize: memsize];
}

- (void*)resizeMem: (void*)ptr
	    toSize: (size_t)size
{
	struct __ofobject_allocated_mem *iter;

	for (iter = __mem_pool; iter != NULL; iter = iter->prev) {
		if (iter->ptr == ptr) {
			if ((ptr = realloc(iter->ptr, size)) == NULL) {
				[[OFNoMemException newWithObject: self
							 andSize: size] raise];
				return iter->ptr;
			}
			
			iter->ptr = ptr;
			return ptr;
		}
	}

	[[OFMemNotPartOfObjException newWithObject: self
					andPointer: ptr] raise];
	return NULL;
}

- (void*)resizeMem: (void*)ptr
	  toNItems: (size_t)nitems
	    ofSize: (size_t)size
{
	size_t memsize;

	if (size > SIZE_MAX / nitems) {
		[[OFOverflowException newWithObject: self] raise];
		return ptr;
	}

	memsize = nitems * size;
	return [self resizeMem: ptr
			toSize: memsize];
}

- freeMem: (void*)ptr;
{
	struct __ofobject_allocated_mem *iter;

	for (iter = __mem_pool; iter != NULL; iter = iter->prev) {
		if (iter->ptr == ptr) {
︙︙

Fossil 2.23 [47362306a7] 2023-11-01 18:56:47
This page was generated in about 0.028s