Index: src/OFStreamObserver.h
==================================================================
--- src/OFStreamObserver.h
+++ src/OFStreamObserver.h
@@ -43,18 +43,18 @@
 /**
  * \brief This callback is called when a stream did get ready for reading.
  *
  * \param stream The stream which did become ready for reading
  */
-- (void)streamDidBecomeReadyForReading: (OFStream*)stream;
+- (void)streamIsReadyForReading: (OFStream*)stream;
 
 /**
  * \brief This callback is called when a stream did get ready for writing.
  *
  * \param stream The stream which did become ready for writing
  */
-- (void)streamDidBecomeReadyForWriting: (OFStream*)stream;
+- (void)streamIsReadyForWriting: (OFStream*)stream;
 
 /**
  * \brief This callback is called when an exception occurred on the stream.
  *
  * \param stream The stream on which an exception occurred
@@ -117,11 +117,11 @@
  * If there is an -[observe] call blocking, it will be canceled. The reason for
  * this is to prevent blocking even though the new added stream is ready.
  *
  * \param stream The stream to observe for reading
  */
-- (void)addStreamToObserveForReading: (OFStream*)stream;
+- (void)addStreamForReading: (OFStream*)stream;
 
 /**
  * \brief Adds a stream to observe for writing.
  *
  * It is recommended that the stream you add is set to non-blocking mode.
@@ -129,31 +129,31 @@
  * If there is an -[observe] call blocking, it will be canceled. The reason for
  * this is to prevent blocking even though the new added stream is ready.
  *
  * \param stream The stream to observe for writing
  */
-- (void)addStreamToObserveForWriting: (OFStream*)stream;
+- (void)addStreamForWriting: (OFStream*)stream;
 
 /**
  * \brief Removes a stream to observe for reading.
  *
  * If there is an -[observe] call blocking, it will be canceled. The reason for
  * this is to prevent the removed stream from still being observed.
  *
  * \param stream The stream to remove from observing for reading
  */
-- (void)removeStreamToObserveForReading: (OFStream*)stream;
+- (void)removeStreamForReading: (OFStream*)stream;
 
 /**
  * \brief Removes a stream to observe for writing.
  *
  * If there is an -[observe] call blocking, it will be canceled. The reason for
  * this is to prevent the removed stream from still being observed.
  *
  * \param stream The stream to remove from observing for writing
  */
-- (void)removeStreamToObserveForWriting: (OFStream*)stream;
+- (void)removeStreamForWriting: (OFStream*)stream;
 
 /**
  * \brief Observes all streams and blocks until an event happens on a stream.
  */
 - (void)observe;

Index: src/OFStreamObserver.m
==================================================================
--- src/OFStreamObserver.m
+++ src/OFStreamObserver.m
@@ -161,11 +161,11 @@
 - (void)setDelegate: (id <OFStreamObserverDelegate>)delegate_
 {
 	OF_SETTER(delegate, delegate_, YES, NO)
 }
 
-- (void)addStreamToObserveForReading: (OFStream*)stream
+- (void)addStreamForReading: (OFStream*)stream
 {
 	OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
 	OFNumber *qi = [OFNumber numberWithInt: QUEUE_ADD | QUEUE_READ];
 
 	@synchronized (queue) {
@@ -181,11 +181,11 @@
 #endif
 
 	[pool release];
 }
 
-- (void)addStreamToObserveForWriting: (OFStream*)stream
+- (void)addStreamForWriting: (OFStream*)stream
 {
 	OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
 	OFNumber *qi = [OFNumber numberWithInt: QUEUE_ADD | QUEUE_WRITE];
 
 	@synchronized (queue) {
@@ -201,11 +201,11 @@
 #endif
 
 	[pool release];
 }
 
-- (void)removeStreamToObserveForReading: (OFStream*)stream
+- (void)removeStreamForReading: (OFStream*)stream
 {
 	OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
 	OFNumber *qi = [OFNumber numberWithInt: QUEUE_REMOVE | QUEUE_READ];
 
 	@synchronized (queue) {
@@ -221,11 +221,11 @@
 #endif
 
 	[pool release];
 }
 
-- (void)removeStreamToObserveForWriting: (OFStream*)stream
+- (void)removeStreamForWriting: (OFStream*)stream
 {
 	OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
 	OFNumber *qi = [OFNumber numberWithInt: QUEUE_REMOVE | QUEUE_WRITE];
 
 	@synchronized (queue) {
@@ -241,29 +241,29 @@
 #endif
 
 	[pool release];
 }
 
-- (void)_addStreamToObserveForReading: (OFStream*)strea;
+- (void)_addStreamForReading: (OFStream*)strea;
+{
+	@throw [OFNotImplementedException newWithClass: isa
+					      selector: _cmd];
+}
+
+- (void)_addStreamForWriting: (OFStream*)stream
 {
 	@throw [OFNotImplementedException newWithClass: isa
 					      selector: _cmd];
 }
 
-- (void)_addStreamToObserveForWriting: (OFStream*)stream
+- (void)_removeStreamForReading: (OFStream*)stream
 {
 	@throw [OFNotImplementedException newWithClass: isa
 					      selector: _cmd];
 }
 
-- (void)_removeStreamToObserveForReading: (OFStream*)stream
-{
-	@throw [OFNotImplementedException newWithClass: isa
-					      selector: _cmd];
-}
-
-- (void)_removeStreamToObserveForWriting: (OFStream*)stream
+- (void)_removeStreamForWriting: (OFStream*)stream
 {
 	@throw [OFNotImplementedException newWithClass: isa
 					      selector: _cmd];
 }
 
@@ -300,35 +300,31 @@
 
 			switch (action) {
 			case QUEUE_ADD | QUEUE_READ:
 				[readStreams addObject: queueCArray[i]];
 
-				[self _addStreamToObserveForReading:
-				    queueCArray[i]];
+				[self _addStreamForReading: queueCArray[i]];
 
 				break;
 			case QUEUE_ADD | QUEUE_WRITE:
 				[writeStreams addObject: queueCArray[i]];
 
-				[self _addStreamToObserveForWriting:
-				    queueCArray[i]];
+				[self _addStreamForWriting: queueCArray[i]];
 
 				break;
 			case QUEUE_REMOVE | QUEUE_READ:
 				[readStreams removeObjectIdenticalTo:
 				    queueCArray[i]];
 
-				[self _removeStreamToObserveForReading:
-				    queueCArray[i]];
+				[self _removeStreamForReading: queueCArray[i]];
 
 				break;
 			case QUEUE_REMOVE | QUEUE_WRITE:
 				[writeStreams removeObjectIdenticalTo:
 				    queueCArray[i]];
 
-				[self _removeStreamToObserveForWriting:
-				    queueCArray[i]];
+				[self _removeStreamForWriting: queueCArray[i]];
 
 				break;
 			default:
 				assert(0);
 			}
@@ -359,11 +355,11 @@
 
 	pool = [[OFAutoreleasePool alloc] init];
 
 	for (i = 0; i < count; i++) {
 		if ([cArray[i] pendingBytes] > 0) {
-			[delegate streamDidBecomeReadyForReading: cArray[i]];
+			[delegate streamIsReadyForReading: cArray[i]];
 			foundInCache = YES;
 			[pool releaseObjects];
 		}
 	}
 
@@ -379,17 +375,17 @@
 	return NO;
 }
 @end
 
 @implementation OFObject (OFStreamObserverDelegate)
-- (void)streamDidBecomeReadyForReading: (OFStream*)stream
+- (void)streamIsReadyForReading: (OFStream*)stream
 {
 }
 
-- (void)streamDidBecomeReadyForWriting: (OFStream*)stream
+- (void)streamIsReadyForWriting: (OFStream*)stream
 {
 }
 
 - (void)streamDidReceiveException: (OFStream*)stream
 {
 }
 @end

Index: src/OFStreamObserver_poll.m
==================================================================
--- src/OFStreamObserver_poll.m
+++ src/OFStreamObserver_poll.m
@@ -99,29 +99,29 @@
 			break;
 		}
 	}
 }
 
-- (void)_addStreamToObserveForReading: (OFStream*)stream
+- (void)_addStreamForReading: (OFStream*)stream
 {
 	[self _addStream: stream
 	      withEvents: POLLIN];
 }
 
-- (void)_addStreamToObserveForWriting: (OFStream*)stream
+- (void)_addStreamForWriting: (OFStream*)stream
 {
 	[self _addStream: stream
 	      withEvents: POLLOUT];
 }
 
-- (void)_removeStreamToObserveForReading: (OFStream*)stream
+- (void)_removeStreamForReading: (OFStream*)stream
 {
 	[self _removeStream: stream
 		 withEvents: POLLIN];
 }
 
-- (void)_removeStreamToObserveForWriting: (OFStream*)stream
+- (void)_removeStreamForWriting: (OFStream*)stream
 {
 	[self _removeStream: stream
 		 withEvents: POLLOUT];
 }
 
@@ -156,17 +156,17 @@
 				FDsCArray[i].revents = 0;
 
 				continue;
 			}
 
-			[delegate streamDidBecomeReadyForReading:
+			[delegate streamIsReadyForReading:
 			    FDToStream[FDsCArray[i].fd]];
 			[pool releaseObjects];
 		}
 
 		if (FDsCArray[i].revents & POLLOUT) {
-			[delegate streamDidBecomeReadyForReading:
+			[delegate streamIsReadyForReading:
 			    FDToStream[FDsCArray[i].fd]];
 			[pool releaseObjects];
 		}
 
 		if (FDsCArray[i].revents & POLLERR) {

Index: src/OFStreamObserver_select.m
==================================================================
--- src/OFStreamObserver_select.m
+++ src/OFStreamObserver_select.m
@@ -39,37 +39,37 @@
 	FD_SET(cancelFD[0], &readFDs);
 
 	return self;
 }
 
-- (void)_addStreamToObserveForReading: (OFStream*)stream
+- (void)_addStreamForReading: (OFStream*)stream
 {
 	int fd = [stream fileDescriptor];
 
 	FD_SET(fd, &readFDs);
 	FD_SET(fd, &exceptFDs);
 }
 
-- (void)_addStreamToObserveForWriting: (OFStream*)stream
+- (void)_addStreamForWriting: (OFStream*)stream
 {
 	int fd = [stream fileDescriptor];
 
 	FD_SET(fd, &writeFDs);
 	FD_SET(fd, &exceptFDs);
 }
 
-- (void)_removeStreamToObserveForReading: (OFStream*)stream
+- (void)_removeStreamForReading: (OFStream*)stream
 {
 	int fd = [stream fileDescriptor];
 
 	FD_CLR(fd, &readFDs);
 
 	if (!FD_ISSET(fd, &writeFDs))
 		FD_CLR(fd, &exceptFDs);
 }
 
-- (void)_removeStreamToObserveForWriting: (OFStream*)stream
+- (void)_removeStreamForWriting: (OFStream*)stream
 {
 	int fd = [stream fileDescriptor];
 
 	FD_CLR(fd, &writeFDs);
 
@@ -123,11 +123,11 @@
 
 	for (i = 0; i < count; i++) {
 		int fileDescriptor = [cArray[i] fileDescriptor];
 
 		if (FD_ISSET(fileDescriptor, &readFDs_)) {
-			[delegate streamDidBecomeReadyForReading: cArray[i]];
+			[delegate streamIsReadyForReading: cArray[i]];
 			[pool releaseObjects];
 		}
 
 		if (FD_ISSET(fileDescriptor, &exceptFDs_)) {
 			[delegate streamDidReceiveException: cArray[i]];
@@ -146,11 +146,11 @@
 
 	for (i = 0; i < count; i++) {
 		int fileDescriptor = [cArray[i] fileDescriptor];
 
 		if (FD_ISSET(fileDescriptor, &writeFDs_)) {
-			[delegate streamDidBecomeReadyForWriting: cArray[i]];
+			[delegate streamIsReadyForWriting: cArray[i]];
 			[pool releaseObjects];
 		}
 
 		if (FD_ISSET(fileDescriptor, &exceptFDs_)) {
 			[delegate streamDidReceiveException: cArray[i]];