ObjFW  Check-in [3de549d6a5]

Overview
Comment:OFStreamObserver: Cancel is no event anymore.

As cancel internally was an event, -[observeWithTimeout:] returned YES
before when an observe call was canceled. Now, the number of real events
is counted and NO returned if this is 0.

Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA3-256: 3de549d6a5689ce6e1b0744f709bcaa7b3c657ecd4737834c90b23fbe3736716
User & Date: js on 2012-09-12 06:00:29
Original User & Date: js on 2012-09-12 06:00:30
Other Links: manifest | tags
Context
2012-09-12
06:00
Make OFSortedList sort stable. check-in: 4357c856cc user: js tags: trunk
06:00
OFStreamObserver: Cancel is no event anymore. check-in: 3de549d6a5 user: js tags: trunk
06:00
OFStreamObserver: Add -[cancel]. check-in: acb6598856 user: js tags: trunk
Changes
Hide Diffs Unified Diffs Ignore Whitespace Patch

Modified src/OFStreamObserver_kqueue.m from [5936ea8b18] to [e69a794cf2].

︙︙
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

}

- (BOOL)observeWithTimeout: (double)timeout
{
	void *pool = objc_autoreleasePoolPush();
	struct timespec timespec;
	struct kevent eventList[EVENTLIST_SIZE];
	int i, events;

	timespec.tv_sec = timeout;
	timespec.tv_nsec = (timeout - timespec.tv_sec) * 1000000000;

	[self _processQueue];

	if ([self _processCache]) {








|








99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

}

- (BOOL)observeWithTimeout: (double)timeout
{
	void *pool = objc_autoreleasePoolPush();
	struct timespec timespec;
	struct kevent eventList[EVENTLIST_SIZE];
	int i, events, realEvents = 0;

	timespec.tv_sec = timeout;
	timespec.tv_nsec = (timeout - timespec.tv_sec) * 1000000000;

	[self _processQueue];

	if ([self _processCache]) {
︙︙
142
143
144
145
146
147
148


149
150
151
152
153
154
155

		if (eventList[i].ident == cancelFD[0]) {
			char buffer;

			OF_ENSURE(read(cancelFD[0], &buffer, 1) > 0);

			continue;
		}



		pool = objc_autoreleasePoolPush();

		if (eventList[i].flags & EV_ERROR) {
			[delegate streamDidReceiveException:
			    FDToStream[eventList[i].ident]];
			objc_autoreleasePoolPop(pool);








>
>








142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

		if (eventList[i].ident == cancelFD[0]) {
			char buffer;

			OF_ENSURE(read(cancelFD[0], &buffer, 1) > 0);

			continue;
		}

		realEvents++;

		pool = objc_autoreleasePoolPush();

		if (eventList[i].flags & EV_ERROR) {
			[delegate streamDidReceiveException:
			    FDToStream[eventList[i].ident]];
			objc_autoreleasePoolPop(pool);
︙︙
167
168
169
170
171
172
173



174
175
176
177

			break;
		default:
			assert(0);
		}

		objc_autoreleasePoolPop(pool);
	}




	return YES;
}
@end








>
>
>





169
170
171
172
173
174
175
176
177
178
179
180
181
182

			break;
		default:
			assert(0);
		}

		objc_autoreleasePoolPop(pool);
	}

	if (realEvents == 0)
		return NO;

	return YES;
}
@end

Modified src/OFStreamObserver_poll.m from [927bd4e34c] to [26ca60eaf1].

︙︙
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

			 withEvents: POLLOUT];
}

- (BOOL)observeWithTimeout: (double)timeout
{
	void *pool = objc_autoreleasePoolPush();
	struct pollfd *FDsCArray;
	size_t i, nFDs;

	[self _processQueue];

	if ([self _processCache]) {
		objc_autoreleasePoolPop(pool);
		return YES;
	}








|








120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

			 withEvents: POLLOUT];
}

- (BOOL)observeWithTimeout: (double)timeout
{
	void *pool = objc_autoreleasePoolPush();
	struct pollfd *FDsCArray;
	size_t i, nFDs, realEvents = 0;

	[self _processQueue];

	if ([self _processCache]) {
		objc_autoreleasePoolPop(pool);
		return YES;
	}
︙︙
157
158
159
160
161
162
163

164
165
166
167
168

169
170
171
172
173

174
175
176
177
178
179
180
181



182
183
184
185

				OF_ENSURE(read(cancelFD[0], &buffer, 1) > 0);
				FDsCArray[i].revents = 0;

				objc_autoreleasePoolPop(pool);
				continue;
			}


			[delegate streamIsReadyForReading:
			    FDToStream[FDsCArray[i].fd]];
		}

		if (FDsCArray[i].revents & POLLOUT) {

			[delegate streamIsReadyForWriting:
			    FDToStream[FDsCArray[i].fd]];
		}

		if (FDsCArray[i].revents & POLLERR) {

			[delegate streamDidReceiveException:
			    FDToStream[FDsCArray[i].fd]];
		}

		FDsCArray[i].revents = 0;

		objc_autoreleasePoolPop(pool);
	}




	return YES;
}
@end








>





>





>








>
>
>





157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191

				OF_ENSURE(read(cancelFD[0], &buffer, 1) > 0);
				FDsCArray[i].revents = 0;

				objc_autoreleasePoolPop(pool);
				continue;
			}

			realEvents++;
			[delegate streamIsReadyForReading:
			    FDToStream[FDsCArray[i].fd]];
		}

		if (FDsCArray[i].revents & POLLOUT) {
			realEvents++;
			[delegate streamIsReadyForWriting:
			    FDToStream[FDsCArray[i].fd]];
		}

		if (FDsCArray[i].revents & POLLERR) {
			realEvents++;
			[delegate streamDidReceiveException:
			    FDToStream[FDsCArray[i].fd]];
		}

		FDsCArray[i].revents = 0;

		objc_autoreleasePoolPop(pool);
	}

	if (realEvents == 0)
		return NO;

	return YES;
}
@end

Modified src/OFStreamObserver_select.m from [a76eca16d0] to [eb397d13f9].

︙︙
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

{
	void *pool = objc_autoreleasePoolPush();
	OFStream **objects;
	fd_set readFDs_;
	fd_set writeFDs_;
	fd_set exceptFDs_;
	struct timeval time;
	size_t i, count;

	[self _processQueue];

	if ([self _processCache]) {
		objc_autoreleasePoolPop(pool);
		return YES;
	}








|








73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

{
	void *pool = objc_autoreleasePoolPush();
	OFStream **objects;
	fd_set readFDs_;
	fd_set writeFDs_;
	fd_set exceptFDs_;
	struct timeval time;
	size_t i, count, realEvents = 0;

	[self _processQueue];

	if ([self _processCache]) {
		objc_autoreleasePoolPop(pool);
		return YES;
	}
︙︙
118
119
120
121
122
123
124
125

126
127

128

129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

150
151

152

153

154
155
156



157
158
159
160

	count = [readStreams count];

	for (i = 0; i < count; i++) {
		int fileDescriptor = [objects[i] fileDescriptor];

		pool = objc_autoreleasePoolPush();

		if (FD_ISSET(fileDescriptor, &readFDs_))

			[delegate streamIsReadyForReading: objects[i]];


		if (FD_ISSET(fileDescriptor, &exceptFDs_)) {

			[delegate streamDidReceiveException: objects[i]];

			/*
			 * Prevent calling it twice in case the FD is in both
			 * sets.
			 */
			FD_CLR(fileDescriptor, &exceptFDs_);
		}

		objc_autoreleasePoolPop(pool);
	}

	objects = [writeStreams objects];
	count = [writeStreams count];

	for (i = 0; i < count; i++) {
		int fileDescriptor = [objects[i] fileDescriptor];

		pool = objc_autoreleasePoolPush();

		if (FD_ISSET(fileDescriptor, &writeFDs_))

			[delegate streamIsReadyForWriting: objects[i]];


		if (FD_ISSET(fileDescriptor, &exceptFDs_))

			[delegate streamDidReceiveException: objects[i]];


		objc_autoreleasePoolPop(pool);
	}




	return YES;
}
@end








|
>

|
>

>




















|
>

|
>
|
>

>



>
>
>





118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

	count = [readStreams count];

	for (i = 0; i < count; i++) {
		int fileDescriptor = [objects[i] fileDescriptor];

		pool = objc_autoreleasePoolPush();

		if (FD_ISSET(fileDescriptor, &readFDs_)) {
			realEvents++;
			[delegate streamIsReadyForReading: objects[i]];
		}

		if (FD_ISSET(fileDescriptor, &exceptFDs_)) {
			realEvents++;
			[delegate streamDidReceiveException: objects[i]];

			/*
			 * Prevent calling it twice in case the FD is in both
			 * sets.
			 */
			FD_CLR(fileDescriptor, &exceptFDs_);
		}

		objc_autoreleasePoolPop(pool);
	}

	objects = [writeStreams objects];
	count = [writeStreams count];

	for (i = 0; i < count; i++) {
		int fileDescriptor = [objects[i] fileDescriptor];

		pool = objc_autoreleasePoolPush();

		if (FD_ISSET(fileDescriptor, &writeFDs_)) {
			realEvents++;
			[delegate streamIsReadyForWriting: objects[i]];
		}

		if (FD_ISSET(fileDescriptor, &exceptFDs_)) {
			realEvents++;
			[delegate streamDidReceiveException: objects[i]];
		}

		objc_autoreleasePoolPop(pool);
	}

	if (realEvents == 0)
		return NO;

	return YES;
}
@end

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