ObjFW

Diff
Login

Differences From Artifact [240d5f78f9]:

To Artifact [1f47484a4e]:


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
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
171


172
173
174
175
176

177
178
179
180

181
182
183
184
185
186
187
188
189
190
191
192
193
194


195
196

197
198
199
200
201
202
203
204
205
206
207
208
209
210


211
212
213
214
215
216
217
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



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







-
+













-
-
-
-
-
-
-
+
-
-
+
-
-
-
+
+
-
-
-
-
+
-
-
-
-
+













-
-
-
-
-
-
-
+
-
-
+
-
-
-
+
+
-
-
-
-
+
-
-
-
-
+








-
-
-
-
-
-
+
+
-
-
-
+
+
-
-
-
-
-
+
-
-
-
-
+








-
-
-
-
-
-
+
+
-
-
+
-
-
-
-
-
-
-







+
+







- (void)dealloc
{
	close(_kernelQueue);

	[super dealloc];
}

- (void)addObjectForReading: (id <OFReadyForReadingObserving>)object
- (void)OF_addObjectForReading: (id <OFReadyForReadingObserving>)object
{
	struct kevent event;

	memset(&event, 0, sizeof(event));
	event.ident = [object fileDescriptorForReading];
	event.filter = EVFILT_READ;
	event.flags = EV_ADD;
#ifndef OF_NETBSD
	event.udata = object;
#else
	event.udata = (intptr_t)object;
#endif

#ifdef OF_HAVE_THREADS
	[_mutex lock];
	@try {
#endif
		[_readObjects addObject: object];

		if (kevent(_kernelQueue, &event, 1, NULL, 0, NULL) != 0) {
	if (kevent(_kernelQueue, &event, 1, NULL, 0, NULL) != 0)
			[_readObjects removeObjectIdenticalTo: object];
			@throw [OFObserveFailedException
		@throw [OFObserveFailedException exceptionWithObserver: self
			    exceptionWithObserver: self
					    errNo: errno];
		}
								 errNo: errno];
}
#ifdef OF_HAVE_THREADS
	} @finally {
		[_mutex unlock];
	}

#endif
}

- (void)addObjectForWriting: (id <OFReadyForWritingObserving>)object
- (void)OF_addObjectForWriting: (id <OFReadyForWritingObserving>)object
{
	struct kevent event;

	memset(&event, 0, sizeof(event));
	event.ident = [object fileDescriptorForWriting];
	event.filter = EVFILT_WRITE;
	event.flags = EV_ADD;
#ifndef OF_NETBSD
	event.udata = object;
#else
	event.udata = (intptr_t)object;
#endif

#ifdef OF_HAVE_THREADS
	[_mutex lock];
	@try {
#endif
		[_writeObjects addObject: object];

		if (kevent(_kernelQueue, &event, 1, NULL, 0, NULL) != 0) {
	if (kevent(_kernelQueue, &event, 1, NULL, 0, NULL) != 0)
			[_writeObjects removeObjectIdenticalTo: object];
			@throw [OFObserveFailedException
		@throw [OFObserveFailedException exceptionWithObserver: self
			    exceptionWithObserver: self
					    errNo: errno];
		}
								 errNo: errno];
}
#ifdef OF_HAVE_THREADS
	} @finally {
		[_mutex unlock];
	}

#endif
}

- (void)removeObjectForReading: (id <OFReadyForReadingObserving>)object
- (void)OF_removeObjectForReading: (id <OFReadyForReadingObserving>)object
{
	struct kevent event;

	memset(&event, 0, sizeof(event));
	event.ident = [object fileDescriptorForReading];
	event.filter = EVFILT_READ;
	event.flags = EV_DELETE;

#ifdef OF_HAVE_THREADS
	[_mutex lock];
	@try {
#endif
		if (kevent(_kernelQueue, &event, 1, NULL, 0, NULL) != 0)
			@throw [OFObserveFailedException
	if (kevent(_kernelQueue, &event, 1, NULL, 0, NULL) != 0)
		@throw [OFObserveFailedException exceptionWithObserver: self
			    exceptionWithObserver: self
					    errNo: errno];

								 errNo: errno];
}
		[_readObjects removeObjectIdenticalTo: object];
#ifdef OF_HAVE_THREADS
	} @finally {
		[_mutex unlock];
	}

#endif
}

- (void)removeObjectForWriting: (id <OFReadyForWritingObserving>)object
- (void)OF_removeObjectForWriting: (id <OFReadyForWritingObserving>)object
{
	struct kevent event;

	memset(&event, 0, sizeof(event));
	event.ident = [object fileDescriptorForWriting];
	event.filter = EVFILT_WRITE;
	event.flags = EV_DELETE;

#ifdef OF_HAVE_THREADS
	[_mutex lock];
	@try {
#endif
		if (kevent(_kernelQueue, &event, 1, NULL, 0, NULL) != 0)
			@throw [OFObserveFailedException
	if (kevent(_kernelQueue, &event, 1, NULL, 0, NULL) != 0)
		@throw [OFObserveFailedException exceptionWithObserver: self
			    exceptionWithObserver: self
					    errNo: errno];
								 errNo: errno];

		[_writeObjects removeObjectIdenticalTo: object];
#ifdef OF_HAVE_THREADS
	} @finally {
		[_mutex unlock];
	}
#endif
}

- (void)observeForTimeInterval: (of_time_interval_t)timeInterval
{
	struct timespec timeout;
	struct kevent eventList[EVENTLIST_SIZE];
	int events;

	[self OF_processQueue];

	if ([self OF_processReadBuffers])
		return;

	timeout.tv_sec = (time_t)timeInterval;
	timeout.tv_nsec = lrint((timeInterval - timeout.tv_sec) * 1000000000);