@@ -16,11 +16,10 @@ #import "OFObject.h" #import "socket.h" -@class OFStream; @class OFMutableArray; @class OFMutableDictionary; @class OFDataArray; #ifdef OF_HAVE_THREADS @class OFMutex; @@ -34,50 +33,74 @@ @protocol OFKernelEventObserverDelegate #ifdef OF_HAVE_OPTIONAL_PROTOCOLS @optional #endif /*! - * @brief This callback is called when a stream did get ready for reading. - * - * @note When @ref OFStream::tryReadLine or - * @ref OFStream::tryReadTillDelimiter: has been called on the stream, - * this callback will not be called again until new data has been - * received, even though there is still data in the cache. The reason for - * this is to prevent spinning in a loop when there is an incomplete - * string in the cache. Once the string is complete, the callback will be - * called again if there is data in the cache. - * - * @param stream The stream which did become ready for reading - */ -- (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)streamIsReadyForWriting: (OFStream*)stream; - -/*! - * @brief This callback is called when an exception occurred on the stream. - * - * @param stream The stream on which an exception occurred - */ -- (void)streamDidReceiveException: (OFStream*)stream; + * @brief This callback is called when an object did get ready for reading. + * + * @note If the object is a subclass of @ref OFStream and + * @ref OFStream::tryReadLine or @ref OFStream::tryReadTillDelimiter: has + * been called on the stream, this callback will not be called again + * until new data has been received, even though there is still data in + * the cache. The reason for this is to prevent spinning in a loop when + * there is an incomplete string in the cache. Once the string has been + * completed, the callback will be called again as long there is data in + * the cache. + * + * @param object The object which did become ready for reading + */ +- (void)objectIsReadyForReading: (id)object; + +/*! + * @brief This callback is called when an object did get ready for writing. + * + * @param object The object which did become ready for writing + */ +- (void)objectIsReadyForWriting: (id)object; +@end + +/*! + * @brief This protocol is implemented by classes which can be observed for + * readiness for reading by OFKernelEventObserver. + */ +@protocol OFReadyForReadingObserving +/*! + * @brief Returns the file descriptor for reading that should be checked by the + * OFKernelEventObserver. + * + * @return The file descriptor for reading that should be checked by the + * OFKernelEventObserver + */ +- (int)fileDescriptorForReading; +@end + +/*! + * @brief This protocol is implemented by classes which can be observed for + * readiness for writing by OFKernelEventObserver. + */ +@protocol OFReadyForWritingObserving +/*! + * @brief Returns the file descriptor for writing that should be checked by the + * OFKernelEventObserver. + * + * @return The file descriptor for writing that should be checked by the + * OFKernelEventObserver + */ +- (int)fileDescriptorForWriting; @end /*! * @brief A class that can observe multiple kernel events (e.g. streams being * ready to read) at once. * - * @note Currently, Win32 can only observe sockets and not files! + * @note Currently, Win32 can only observe TCP sockets! */ @interface OFKernelEventObserver: OFObject { - OFMutableArray *_readStreams; - OFMutableArray *_writeStreams; - __unsafe_unretained OFStream **_FDToStream; + OFMutableArray *_readObjects; + OFMutableArray *_writeObjects; + __unsafe_unretained id *_FDToObject; size_t _maxFD; OFMutableArray *_queue; OFDataArray *_queueInfo, *_queueFDs; id _delegate; int _cancelFD[2]; @@ -113,87 +136,83 @@ * @param delegate The delegate for the OFKernelEventObserver */ - (void)setDelegate: (id )delegate; /*! - * @brief Adds a stream to observe for reading. - * - * This is also used to observe a listening socket for incoming connections, - * which then triggers a read event for the observed stream. - * - * It is recommended that the stream you add is set to non-blocking mode. - * - * If there is an @ref 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)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. - * - * If there is an @ref 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)addStreamForWriting: (OFStream*)stream; - -/*! - * @brief Removes a stream to observe for reading. - * - * If there is an @ref 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)removeStreamForReading: (OFStream*)stream; - -/*! - * @brief Removes a stream to observe for writing. - * - * If there is an @ref 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)removeStreamForWriting: (OFStream*)stream; - -/*! - * @brief Observes all streams and blocks until an event happens on a stream. + * @brief Adds an object to observe for reading. + * + * This is also used to observe a listening socket for incoming connections, + * which then triggers a read event for the observed object. + * + * If there is an @ref observe call blocking, it will be canceled. The reason + * for this is to prevent blocking even though the newly added object is ready. + * + * @param object The object to observe for reading + */ +- (void)addObjectForReading: (id )object; + +/*! + * @brief Adds an object to observe for writing. + * + * If there is an @ref observe call blocking, it will be canceled. The reason + * for this is to prevent blocking even though the newly added object is ready. + * + * @param object The object to observe for writing + */ +- (void)addObjectForWriting: (id )object; + +/*! + * @brief Removes an object to observe for reading. + * + * If there is an @ref observe call blocking, it will be canceled. The reason + * for this is to prevent the removed object from still being observed. + * + * @param object The object to remove from observing for reading + */ +- (void)removeObjectForReading: (id )object; + +/*! + * @brief Removes an object to observe for writing. + * + * If there is an @ref observe call blocking, it will be canceled. The reason + * for this is to prevent the removed object from still being observed. + * + * @param object The object to remove from observing for writing + */ +- (void)removeObjectForWriting: (id )object; + +/*! + * @brief Observes all objects and blocks until an event happens on an object. */ - (void)observe; /*! - * @brief Observes all streams until an event happens on a stream or the + * @brief Observes all objects until an event happens on an object or the * timeout is reached. * * @param timeInterval The time to wait for an event, in seconds * @return A boolean whether events occurred during the timeinterval */ - (bool)observeForTimeInterval: (of_time_interval_t)timeInterval; /*! - * @brief Observes all streams until an event happens on a stream or the - * timeout is reached. + * @brief Observes all objects until an event happens on an object or the + * specified date is reached. * * @param date The until which to observe * @return A boolean whether events occurred until the specified date */ - (bool)observeUntilDate: (OFDate*)date; /*! * @brief Cancels the currently blocking observe call. * - * This is automatically done when a new stream is added or removed by another + * This is automatically done when a new object is added or removed by another * thread, but in some circumstances, it might be desirable for a thread to * manually stop the observe running in another thread. */ - (void)cancel; @end @interface OFObject (OFKernelEventObserverDelegate) @end