laipower/wp-content/plugins/wp-webauthn/wp-webauthn-vendor/thecodingmachine/safe/deprecated/libevent.php

497 lines
13 KiB
PHP
Raw Normal View History

<?php
namespace Safe;
use Safe\Exceptions\LibeventException;
/**
* event_add schedules the execution of the event
* when the event specified in event_set occurs or in at least the time
* specified by the timeout argument. If
* timeout was not specified, not timeout is set. The
* event must be already initalized by event_set
* and event_base_set functions. If the
* event already has a timeout set, it is replaced by
* the new one.
*
* @param resource $event Valid event resource.
* @param int $timeout Optional timeout (in microseconds).
* @throws LibeventException
*
*/
function event_add($event, int $timeout = -1): void
{
error_clear_last();
$result = \event_add($event, $timeout);
if ($result === false) {
throw LibeventException::createFromPhpError();
}
}
/**
* Abort the active event loop immediately. The behaviour is similar to
* break statement.
*
* @param resource $event_base Valid event base resource.
* @throws LibeventException
*
*/
function event_base_loopbreak($event_base): void
{
error_clear_last();
$result = \event_base_loopbreak($event_base);
if ($result === false) {
throw LibeventException::createFromPhpError();
}
}
/**
* The next event loop iteration after the given timer expires will complete
* normally, then exit without blocking for events again.
*
* @param resource $event_base Valid event base resource.
* @param int $timeout Optional timeout parameter (in microseconds).
* @throws LibeventException
*
*/
function event_base_loopexit($event_base, int $timeout = -1): void
{
error_clear_last();
$result = \event_base_loopexit($event_base, $timeout);
if ($result === false) {
throw LibeventException::createFromPhpError();
}
}
/**
* Returns new event base, which can be used later in event_base_set,
* event_base_loop and other functions.
*
* @return resource event_base_new returns valid event base resource on
* success.
* @throws LibeventException
*
*/
function event_base_new()
{
error_clear_last();
$result = \event_base_new();
if ($result === false) {
throw LibeventException::createFromPhpError();
}
return $result;
}
/**
* Sets the number of different event priority levels.
*
* By default all events are scheduled with the same priority
* (npriorities/2).
* Using event_base_priority_init you can change the number
* of event priority levels and then set a desired priority for each event.
*
* @param resource $event_base Valid event base resource.
* @param int $npriorities The number of event priority levels.
* @throws LibeventException
*
*/
function event_base_priority_init($event_base, int $npriorities): void
{
error_clear_last();
$result = \event_base_priority_init($event_base, $npriorities);
if ($result === false) {
throw LibeventException::createFromPhpError();
}
}
/**
* Some event mechanisms do not survive across fork. The
* event_base needs to be reinitialized with this
* function.
*
* @param resource $event_base Valid event base resource that needs to be re-initialized.
* @throws LibeventException
*
*/
function event_base_reinit($event_base): void
{
error_clear_last();
$result = \event_base_reinit($event_base);
if ($result === false) {
throw LibeventException::createFromPhpError();
}
}
/**
* Associates the event_base with the
* event.
*
* @param resource $event Valid event resource.
* @param resource $event_base Valid event base resource.
* @throws LibeventException
*
*/
function event_base_set($event, $event_base): void
{
error_clear_last();
$result = \event_base_set($event, $event_base);
if ($result === false) {
throw LibeventException::createFromPhpError();
}
}
/**
* Assign the specified bevent to the
* event_base.
*
* @param resource $bevent Valid buffered event resource.
* @param resource $event_base Valid event base resource.
* @throws LibeventException
*
*/
function event_buffer_base_set($bevent, $event_base): void
{
error_clear_last();
$result = \event_buffer_base_set($bevent, $event_base);
if ($result === false) {
throw LibeventException::createFromPhpError();
}
}
/**
* Disables the specified buffered event.
*
* @param resource $bevent Valid buffered event resource.
* @param int $events Any combination of EV_READ and
* EV_WRITE.
* @throws LibeventException
*
*/
function event_buffer_disable($bevent, int $events): void
{
error_clear_last();
$result = \event_buffer_disable($bevent, $events);
if ($result === false) {
throw LibeventException::createFromPhpError();
}
}
/**
* Enables the specified buffered event.
*
* @param resource $bevent Valid buffered event resource.
* @param int $events Any combination of EV_READ and
* EV_WRITE.
* @throws LibeventException
*
*/
function event_buffer_enable($bevent, int $events): void
{
error_clear_last();
$result = \event_buffer_enable($bevent, $events);
if ($result === false) {
throw LibeventException::createFromPhpError();
}
}
/**
* Libevent provides an abstraction layer on top of the regular event API.
* Using buffered event you don't need to deal with the I/O manually, instead
* it provides input and output buffers that get filled and drained
* automatically.
*
* @param resource $stream Valid PHP stream resource. Must be castable to file descriptor.
* @param mixed $readcb Callback to invoke where there is data to read, or NULL if
* no callback is desired.
* @param mixed $writecb Callback to invoke where the descriptor is ready for writing,
* or NULL if no callback is desired.
* @param mixed $errorcb Callback to invoke where there is an error on the descriptor, cannot be
* NULL.
* @param mixed $arg An argument that will be passed to each of the callbacks (optional).
* @return resource event_buffer_new returns new buffered event resource
* on success.
* @throws LibeventException
*
*/
function event_buffer_new($stream, $readcb, $writecb, $errorcb, $arg = null)
{
error_clear_last();
if ($arg !== null) {
$result = \event_buffer_new($stream, $readcb, $writecb, $errorcb, $arg);
} else {
$result = \event_buffer_new($stream, $readcb, $writecb, $errorcb);
}
if ($result === false) {
throw LibeventException::createFromPhpError();
}
return $result;
}
/**
* Assign a priority to the bevent.
*
* @param resource $bevent Valid buffered event resource.
* @param int $priority Priority level. Cannot be less than zero and cannot exceed maximum
* priority level of the event base (see event_base_priority_init).
* @throws LibeventException
*
*/
function event_buffer_priority_set($bevent, int $priority): void
{
error_clear_last();
$result = \event_buffer_priority_set($bevent, $priority);
if ($result === false) {
throw LibeventException::createFromPhpError();
}
}
/**
* Sets or changes existing callbacks for the buffered event.
*
* @param resource $event Valid buffered event resource.
* @param mixed $readcb Callback to invoke where there is data to read, or NULL if
* no callback is desired.
* @param mixed $writecb Callback to invoke where the descriptor is ready for writing,
* or NULL if no callback is desired.
* @param mixed $errorcb Callback to invoke where there is an error on the descriptor, cannot be
* NULL.
* @param mixed $arg An argument that will be passed to each of the callbacks (optional).
* @throws LibeventException
*
*/
function event_buffer_set_callback($event, $readcb, $writecb, $errorcb, $arg = null): void
{
error_clear_last();
if ($arg !== null) {
$result = \event_buffer_set_callback($event, $readcb, $writecb, $errorcb, $arg);
} else {
$result = \event_buffer_set_callback($event, $readcb, $writecb, $errorcb);
}
if ($result === false) {
throw LibeventException::createFromPhpError();
}
}
/**
* Writes data to the specified buffered event. The data is appended to the
* output buffer and written to the descriptor when it becomes available for
* writing.
*
* @param resource $bevent Valid buffered event resource.
* @param string $data The data to be written.
* @param int $data_size Optional size parameter. event_buffer_write writes
* all the data by default.
* @throws LibeventException
*
*/
function event_buffer_write($bevent, string $data, int $data_size = -1): void
{
error_clear_last();
$result = \event_buffer_write($bevent, $data, $data_size);
if ($result === false) {
throw LibeventException::createFromPhpError();
}
}
/**
* Cancels the event.
*
* @param resource $event Valid event resource.
* @throws LibeventException
*
*/
function event_del($event): void
{
error_clear_last();
$result = \event_del($event);
if ($result === false) {
throw LibeventException::createFromPhpError();
}
}
/**
* Creates and returns a new event resource.
*
* @return resource event_new returns a new event resource on success.
* @throws LibeventException
*
*/
function event_new()
{
error_clear_last();
$result = \event_new();
if ($result === false) {
throw LibeventException::createFromPhpError();
}
return $result;
}
/**
* Assign a priority to the event.
*
* @param resource $event Valid event resource.
* @param int $priority Priority level. Cannot be less than zero and cannot exceed maximum
* priority level of the event base (see
* event_base_priority_init).
* @throws LibeventException
*
*/
function event_priority_set($event, int $priority): void
{
error_clear_last();
$result = \event_priority_set($event, $priority);
if ($result === false) {
throw LibeventException::createFromPhpError();
}
}
/**
* Prepares the event to be used in event_add. The event
* is prepared to call the function specified by the callback
* on the events specified in parameter events, which
* is a set of the following flags: EV_TIMEOUT,
* EV_SIGNAL, EV_READ,
* EV_WRITE and EV_PERSIST.
*
* If EV_SIGNAL bit is set in parameter events,
* the fd is interpreted as signal number.
*
* After initializing the event, use event_base_set to
* associate the event with its event base.
*
* In case of matching event, these three arguments are passed to the
* callback function:
*
*
* fd
*
*
* Signal number or resource indicating the stream.
*
*
*
*
* events
*
*
* A flag indicating the event. Consists of the following flags:
* EV_TIMEOUT, EV_SIGNAL,
* EV_READ, EV_WRITE
* and EV_PERSIST.
*
*
*
*
* arg
*
*
* Optional parameter, previously passed to event_set
* as arg.
*
*
*
*
*
* @param resource $event Valid event resource.
* @param mixed $fd Valid PHP stream resource. The stream must be castable to file
* descriptor, so you most likely won't be able to use any of filtered
* streams.
* @param int $events A set of flags indicating the desired event, can be
* EV_READ and/or EV_WRITE.
* The additional flag EV_PERSIST makes the event
* to persist until event_del is called, otherwise
* the callback is invoked only once.
* @param mixed $callback Callback function to be called when the matching event occurs.
* @param mixed $arg Optional callback parameter.
* @throws LibeventException
*
*/
function event_set($event, $fd, int $events, $callback, $arg = null): void
{
error_clear_last();
if ($arg !== null) {
$result = \event_set($event, $fd, $events, $callback, $arg);
} else {
$result = \event_set($event, $fd, $events, $callback);
}
if ($result === false) {
throw LibeventException::createFromPhpError();
}
}
/**
* Prepares the timer event to be used in event_add. The
* event is prepared to call the function specified by the
* callback when the event timeout elapses.
*
* After initializing the event, use event_base_set to
* associate the event with its event base.
*
* In case of matching event, these three arguments are passed to the
* callback function:
*
*
* fd
*
*
* Signal number or resource indicating the stream.
*
*
*
*
* events
*
*
* A flag indicating the event. This will always be
* EV_TIMEOUT for timer events.
*
*
*
*
* arg
*
*
* Optional parameter, previously passed to
* event_timer_set as arg.
*
*
*
*
*
* @param resource $event Valid event resource.
* @param callable $callback Callback function to be called when the matching event occurs.
* @param mixed $arg Optional callback parameter.
* @throws LibeventException
*
*/
function event_timer_set($event, callable $callback, $arg = null): void
{
error_clear_last();
if ($arg !== null) {
$result = \event_timer_set($event, $callback, $arg);
} else {
$result = \event_timer_set($event, $callback);
}
if ($result === false) {
throw LibeventException::createFromPhpError();
}
}