1<?php 2 3namespace Safe; 4 5use Safe\Exceptions\LibeventException; 6 7/** 8 * event_add schedules the execution of the event 9 * when the event specified in event_set occurs or in at least the time 10 * specified by the timeout argument. If 11 * timeout was not specified, not timeout is set. The 12 * event must be already initalized by event_set 13 * and event_base_set functions. If the 14 * event already has a timeout set, it is replaced by 15 * the new one. 16 * 17 * @param resource $event Valid event resource. 18 * @param int $timeout Optional timeout (in microseconds). 19 * @throws LibeventException 20 * 21 */ 22function event_add($event, int $timeout = -1): void 23{ 24 error_clear_last(); 25 $result = \event_add($event, $timeout); 26 if ($result === false) { 27 throw LibeventException::createFromPhpError(); 28 } 29} 30 31 32/** 33 * Abort the active event loop immediately. The behaviour is similar to 34 * break statement. 35 * 36 * @param resource $event_base Valid event base resource. 37 * @throws LibeventException 38 * 39 */ 40function event_base_loopbreak($event_base): void 41{ 42 error_clear_last(); 43 $result = \event_base_loopbreak($event_base); 44 if ($result === false) { 45 throw LibeventException::createFromPhpError(); 46 } 47} 48 49 50/** 51 * The next event loop iteration after the given timer expires will complete 52 * normally, then exit without blocking for events again. 53 * 54 * @param resource $event_base Valid event base resource. 55 * @param int $timeout Optional timeout parameter (in microseconds). 56 * @throws LibeventException 57 * 58 */ 59function event_base_loopexit($event_base, int $timeout = -1): void 60{ 61 error_clear_last(); 62 $result = \event_base_loopexit($event_base, $timeout); 63 if ($result === false) { 64 throw LibeventException::createFromPhpError(); 65 } 66} 67 68 69/** 70 * Returns new event base, which can be used later in event_base_set, 71 * event_base_loop and other functions. 72 * 73 * @return resource event_base_new returns valid event base resource on 74 * success. 75 * @throws LibeventException 76 * 77 */ 78function event_base_new() 79{ 80 error_clear_last(); 81 $result = \event_base_new(); 82 if ($result === false) { 83 throw LibeventException::createFromPhpError(); 84 } 85 return $result; 86} 87 88 89/** 90 * Sets the number of different event priority levels. 91 * 92 * By default all events are scheduled with the same priority 93 * (npriorities/2). 94 * Using event_base_priority_init you can change the number 95 * of event priority levels and then set a desired priority for each event. 96 * 97 * @param resource $event_base Valid event base resource. 98 * @param int $npriorities The number of event priority levels. 99 * @throws LibeventException 100 * 101 */ 102function event_base_priority_init($event_base, int $npriorities): void 103{ 104 error_clear_last(); 105 $result = \event_base_priority_init($event_base, $npriorities); 106 if ($result === false) { 107 throw LibeventException::createFromPhpError(); 108 } 109} 110 111 112/** 113 * Some event mechanisms do not survive across fork. The 114 * event_base needs to be reinitialized with this 115 * function. 116 * 117 * @param resource $event_base Valid event base resource that needs to be re-initialized. 118 * @throws LibeventException 119 * 120 */ 121function event_base_reinit($event_base): void 122{ 123 error_clear_last(); 124 $result = \event_base_reinit($event_base); 125 if ($result === false) { 126 throw LibeventException::createFromPhpError(); 127 } 128} 129 130 131/** 132 * Associates the event_base with the 133 * event. 134 * 135 * @param resource $event Valid event resource. 136 * @param resource $event_base Valid event base resource. 137 * @throws LibeventException 138 * 139 */ 140function event_base_set($event, $event_base): void 141{ 142 error_clear_last(); 143 $result = \event_base_set($event, $event_base); 144 if ($result === false) { 145 throw LibeventException::createFromPhpError(); 146 } 147} 148 149 150/** 151 * Assign the specified bevent to the 152 * event_base. 153 * 154 * @param resource $bevent Valid buffered event resource. 155 * @param resource $event_base Valid event base resource. 156 * @throws LibeventException 157 * 158 */ 159function event_buffer_base_set($bevent, $event_base): void 160{ 161 error_clear_last(); 162 $result = \event_buffer_base_set($bevent, $event_base); 163 if ($result === false) { 164 throw LibeventException::createFromPhpError(); 165 } 166} 167 168 169/** 170 * Disables the specified buffered event. 171 * 172 * @param resource $bevent Valid buffered event resource. 173 * @param int $events Any combination of EV_READ and 174 * EV_WRITE. 175 * @throws LibeventException 176 * 177 */ 178function event_buffer_disable($bevent, int $events): void 179{ 180 error_clear_last(); 181 $result = \event_buffer_disable($bevent, $events); 182 if ($result === false) { 183 throw LibeventException::createFromPhpError(); 184 } 185} 186 187 188/** 189 * Enables the specified buffered event. 190 * 191 * @param resource $bevent Valid buffered event resource. 192 * @param int $events Any combination of EV_READ and 193 * EV_WRITE. 194 * @throws LibeventException 195 * 196 */ 197function event_buffer_enable($bevent, int $events): void 198{ 199 error_clear_last(); 200 $result = \event_buffer_enable($bevent, $events); 201 if ($result === false) { 202 throw LibeventException::createFromPhpError(); 203 } 204} 205 206 207/** 208 * Libevent provides an abstraction layer on top of the regular event API. 209 * Using buffered event you don't need to deal with the I/O manually, instead 210 * it provides input and output buffers that get filled and drained 211 * automatically. 212 * 213 * @param resource $stream Valid PHP stream resource. Must be castable to file descriptor. 214 * @param mixed $readcb Callback to invoke where there is data to read, or NULL if 215 * no callback is desired. 216 * @param mixed $writecb Callback to invoke where the descriptor is ready for writing, 217 * or NULL if no callback is desired. 218 * @param mixed $errorcb Callback to invoke where there is an error on the descriptor, cannot be 219 * NULL. 220 * @param mixed $arg An argument that will be passed to each of the callbacks (optional). 221 * @return resource event_buffer_new returns new buffered event resource 222 * on success. 223 * @throws LibeventException 224 * 225 */ 226function event_buffer_new($stream, $readcb, $writecb, $errorcb, $arg = null) 227{ 228 error_clear_last(); 229 if ($arg !== null) { 230 $result = \event_buffer_new($stream, $readcb, $writecb, $errorcb, $arg); 231 } else { 232 $result = \event_buffer_new($stream, $readcb, $writecb, $errorcb); 233 } 234 if ($result === false) { 235 throw LibeventException::createFromPhpError(); 236 } 237 return $result; 238} 239 240 241/** 242 * Assign a priority to the bevent. 243 * 244 * @param resource $bevent Valid buffered event resource. 245 * @param int $priority Priority level. Cannot be less than zero and cannot exceed maximum 246 * priority level of the event base (see event_base_priority_init). 247 * @throws LibeventException 248 * 249 */ 250function event_buffer_priority_set($bevent, int $priority): void 251{ 252 error_clear_last(); 253 $result = \event_buffer_priority_set($bevent, $priority); 254 if ($result === false) { 255 throw LibeventException::createFromPhpError(); 256 } 257} 258 259 260/** 261 * Sets or changes existing callbacks for the buffered event. 262 * 263 * @param resource $event Valid buffered event resource. 264 * @param mixed $readcb Callback to invoke where there is data to read, or NULL if 265 * no callback is desired. 266 * @param mixed $writecb Callback to invoke where the descriptor is ready for writing, 267 * or NULL if no callback is desired. 268 * @param mixed $errorcb Callback to invoke where there is an error on the descriptor, cannot be 269 * NULL. 270 * @param mixed $arg An argument that will be passed to each of the callbacks (optional). 271 * @throws LibeventException 272 * 273 */ 274function event_buffer_set_callback($event, $readcb, $writecb, $errorcb, $arg = null): void 275{ 276 error_clear_last(); 277 if ($arg !== null) { 278 $result = \event_buffer_set_callback($event, $readcb, $writecb, $errorcb, $arg); 279 } else { 280 $result = \event_buffer_set_callback($event, $readcb, $writecb, $errorcb); 281 } 282 if ($result === false) { 283 throw LibeventException::createFromPhpError(); 284 } 285} 286 287 288/** 289 * Writes data to the specified buffered event. The data is appended to the 290 * output buffer and written to the descriptor when it becomes available for 291 * writing. 292 * 293 * @param resource $bevent Valid buffered event resource. 294 * @param string $data The data to be written. 295 * @param int $data_size Optional size parameter. event_buffer_write writes 296 * all the data by default. 297 * @throws LibeventException 298 * 299 */ 300function event_buffer_write($bevent, string $data, int $data_size = -1): void 301{ 302 error_clear_last(); 303 $result = \event_buffer_write($bevent, $data, $data_size); 304 if ($result === false) { 305 throw LibeventException::createFromPhpError(); 306 } 307} 308 309 310/** 311 * Cancels the event. 312 * 313 * @param resource $event Valid event resource. 314 * @throws LibeventException 315 * 316 */ 317function event_del($event): void 318{ 319 error_clear_last(); 320 $result = \event_del($event); 321 if ($result === false) { 322 throw LibeventException::createFromPhpError(); 323 } 324} 325 326 327/** 328 * Creates and returns a new event resource. 329 * 330 * @return resource event_new returns a new event resource on success. 331 * @throws LibeventException 332 * 333 */ 334function event_new() 335{ 336 error_clear_last(); 337 $result = \event_new(); 338 if ($result === false) { 339 throw LibeventException::createFromPhpError(); 340 } 341 return $result; 342} 343 344 345/** 346 * Assign a priority to the event. 347 * 348 * @param resource $event Valid event resource. 349 * @param int $priority Priority level. Cannot be less than zero and cannot exceed maximum 350 * priority level of the event base (see 351 * event_base_priority_init). 352 * @throws LibeventException 353 * 354 */ 355function event_priority_set($event, int $priority): void 356{ 357 error_clear_last(); 358 $result = \event_priority_set($event, $priority); 359 if ($result === false) { 360 throw LibeventException::createFromPhpError(); 361 } 362} 363 364 365/** 366 * Prepares the event to be used in event_add. The event 367 * is prepared to call the function specified by the callback 368 * on the events specified in parameter events, which 369 * is a set of the following flags: EV_TIMEOUT, 370 * EV_SIGNAL, EV_READ, 371 * EV_WRITE and EV_PERSIST. 372 * 373 * If EV_SIGNAL bit is set in parameter events, 374 * the fd is interpreted as signal number. 375 * 376 * After initializing the event, use event_base_set to 377 * associate the event with its event base. 378 * 379 * In case of matching event, these three arguments are passed to the 380 * callback function: 381 * 382 * 383 * fd 384 * 385 * 386 * Signal number or resource indicating the stream. 387 * 388 * 389 * 390 * 391 * events 392 * 393 * 394 * A flag indicating the event. Consists of the following flags: 395 * EV_TIMEOUT, EV_SIGNAL, 396 * EV_READ, EV_WRITE 397 * and EV_PERSIST. 398 * 399 * 400 * 401 * 402 * arg 403 * 404 * 405 * Optional parameter, previously passed to event_set 406 * as arg. 407 * 408 * 409 * 410 * 411 * 412 * @param resource $event Valid event resource. 413 * @param mixed $fd Valid PHP stream resource. The stream must be castable to file 414 * descriptor, so you most likely won't be able to use any of filtered 415 * streams. 416 * @param int $events A set of flags indicating the desired event, can be 417 * EV_READ and/or EV_WRITE. 418 * The additional flag EV_PERSIST makes the event 419 * to persist until event_del is called, otherwise 420 * the callback is invoked only once. 421 * @param mixed $callback Callback function to be called when the matching event occurs. 422 * @param mixed $arg Optional callback parameter. 423 * @throws LibeventException 424 * 425 */ 426function event_set($event, $fd, int $events, $callback, $arg = null): void 427{ 428 error_clear_last(); 429 if ($arg !== null) { 430 $result = \event_set($event, $fd, $events, $callback, $arg); 431 } else { 432 $result = \event_set($event, $fd, $events, $callback); 433 } 434 if ($result === false) { 435 throw LibeventException::createFromPhpError(); 436 } 437} 438 439 440/** 441 * Prepares the timer event to be used in event_add. The 442 * event is prepared to call the function specified by the 443 * callback when the event timeout elapses. 444 * 445 * After initializing the event, use event_base_set to 446 * associate the event with its event base. 447 * 448 * In case of matching event, these three arguments are passed to the 449 * callback function: 450 * 451 * 452 * fd 453 * 454 * 455 * Signal number or resource indicating the stream. 456 * 457 * 458 * 459 * 460 * events 461 * 462 * 463 * A flag indicating the event. This will always be 464 * EV_TIMEOUT for timer events. 465 * 466 * 467 * 468 * 469 * arg 470 * 471 * 472 * Optional parameter, previously passed to 473 * event_timer_set as arg. 474 * 475 * 476 * 477 * 478 * 479 * @param resource $event Valid event resource. 480 * @param callable $callback Callback function to be called when the matching event occurs. 481 * @param mixed $arg Optional callback parameter. 482 * @throws LibeventException 483 * 484 */ 485function event_timer_set($event, callable $callback, $arg = null): void 486{ 487 error_clear_last(); 488 if ($arg !== null) { 489 $result = \event_timer_set($event, $callback, $arg); 490 } else { 491 $result = \event_timer_set($event, $callback); 492 } 493 if ($result === false) { 494 throw LibeventException::createFromPhpError(); 495 } 496} 497