xle/tt-rss
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

upgrade idiorm to php8.1-patched version (aaronpk/idiorm)

Browse Source
This commit is contained in:
Andrew Dolgov
2022-07-12 22:26:21 +03:00
parent 4b61618920
commit 80d3db1dcf
189 changed files with 17077 additions and 12739 deletions
Download Patch File Download Diff File Expand all files Collapse all files

300
vendor/thecodingmachine/safe/generated/sem.php vendored
View File

@@ -4,6 +4,34 @@ namespace Safe;
use Safe\Exceptions\SemException;
/**
* msg_get_queue returns an id that can be used to
* access the System V message queue with the given
* key. The first call creates the message queue with
* the optional permissions.
* A second call to msg_get_queue for the same
* key will return a different message queue
* identifier, but both identifiers access the same underlying message
* queue.
*
* @param int $key Message queue numeric ID
* @param int $permissions Queue permissions. Default to 0666. If the message queue already
* exists, the permissions will be ignored.
* @return resource Returns SysvMessageQueue instance that can be used to access the System V message queue.
* @throws SemException
*
*/
function msg_get_queue(int $key, int $permissions = 0666)
{
error_clear_last();
$result = \msg_get_queue($key, $permissions);
if ($result === false) {
throw SemException::createFromPhpError();
}
return $result;
}
/**
* Checks whether the message queue key exists.
*
@@ -24,23 +52,23 @@ function msg_queue_exists(int $key): void
/**
* msg_receive will receive the first message from the
* specified queue of the type specified by
* desiredmsgtype.
* desired_message_type.
*
* @param resource $queue Message queue resource handle
* @param int $desiredmsgtype If desiredmsgtype is 0, the message from the front
* of the queue is returned. If desiredmsgtype is
* @param resource $queue The message queue.
* @param int $desired_message_type If desired_message_type is 0, the message from the front
* of the queue is returned. If desired_message_type is
* greater than 0, then the first message of that type is returned.
* If desiredmsgtype is less than 0, the first
* If desired_message_type is less than 0, the first
* message on the queue with a type less than or equal to the
* absolute value of desiredmsgtype will be read.
* absolute value of desired_message_type will be read.
* If no messages match the criteria, your script will wait until a suitable
* message arrives on the queue. You can prevent the script from blocking
* by specifying MSG_IPC_NOWAIT in the
* flags parameter.
* @param int|null $msgtype The type of the message that was received will be stored in this
* @param int|null $received_message_type The type of the message that was received will be stored in this
* parameter.
* @param int $maxsize The maximum size of message to be accepted is specified by the
* maxsize; if the message in the queue is larger
* @param int $max_message_size The maximum size of message to be accepted is specified by the
* max_message_size; if the message in the queue is larger
* than this size the function will fail (unless you set
* flags as described below).
* @param mixed $message The received message will be stored in message,
@@ -64,7 +92,7 @@ function msg_queue_exists(int $key): void
*
* MSG_IPC_NOWAIT
* If there are no messages of the
* desiredmsgtype, return immediately and do not
* desired_message_type, return immediately and do not
* wait. The function will fail and return an integer value
* corresponding to MSG_ENOMSG.
*
@@ -72,30 +100,30 @@ function msg_queue_exists(int $key): void
*
* MSG_EXCEPT
* Using this flag in combination with a
* desiredmsgtype greater than 0 will cause the
* desired_message_type greater than 0 will cause the
* function to receive the first message that is not equal to
* desiredmsgtype.
* desired_message_type.
*
*
* MSG_NOERROR
*
* If the message is longer than maxsize,
* If the message is longer than max_message_size,
* setting this flag will truncate the message to
* maxsize and will not signal an error.
* max_message_size and will not signal an error.
*
*
*
*
*
* @param int|null $errorcode If the function fails, the optional errorcode
* @param int|null $error_code If the function fails, the optional error_code
* will be set to the value of the system errno variable.
* @throws SemException
*
*/
function msg_receive($queue, int $desiredmsgtype, ?int &$msgtype, int $maxsize, &$message, bool $unserialize = true, int $flags = 0, ?int &$errorcode = null): void
function msg_receive($queue, int $desired_message_type, ?int &$received_message_type, int $max_message_size, &$message, bool $unserialize = true, int $flags = 0, ?int &$error_code = null): void
{
error_clear_last();
$result = \msg_receive($queue, $desiredmsgtype, $msgtype, $maxsize, $message, $unserialize, $flags, $errorcode);
$result = \msg_receive($queue, $desired_message_type, $received_message_type, $max_message_size, $message, $unserialize, $flags, $error_code);
if ($result === false) {
throw SemException::createFromPhpError();
}
@@ -108,7 +136,7 @@ function msg_receive($queue, int $desiredmsgtype, ?int &$msgtype, int $maxsize,
* processes have finished working with the message queue and you need to
* release the system resources held by it.
*
* @param resource $queue Message queue resource handle
* @param resource $queue The message queue.
* @throws SemException
*
*/
@@ -124,15 +152,15 @@ function msg_remove_queue($queue): void
/**
* msg_send sends a message of type
* msgtype (which MUST be greater than 0) to
* message_type (which MUST be greater than 0) to
* the message queue specified by queue.
*
* @param resource $queue Message queue resource handle
* @param int $msgtype The type of the message (MUST be greater than 0)
* @param resource $queue The message queue.
* @param int $message_type The type of the message (MUST be greater than 0)
* @param mixed $message The body of the message.
*
* If serialize set to FALSE is supplied,
* MUST be of type: string, integer, float
* MUST be of type: string, int, float
* or bool. In other case a warning will be issued.
* @param bool $serialize The optional serialize controls how the
* message is sent. serialize
@@ -148,17 +176,17 @@ function msg_remove_queue($queue): void
* optional blocking parameter to FALSE, in which
* case msg_send will immediately return FALSE if the
* message is too big for the queue, and set the optional
* errorcode to MSG_EAGAIN,
* error_code to MSG_EAGAIN,
* indicating that you should try to send your message again a little
* later on.
* @param int|null $errorcode If the function fails, the optional errorcode will be set to the value of the system errno variable.
* @param int|null $error_code If the function fails, the optional errorcode will be set to the value of the system errno variable.
* @throws SemException
*
*/
function msg_send($queue, int $msgtype, $message, bool $serialize = true, bool $blocking = true, ?int &$errorcode = null): void
function msg_send($queue, int $message_type, $message, bool $serialize = true, bool $blocking = true, ?int &$error_code = null): void
{
error_clear_last();
$result = \msg_send($queue, $msgtype, $message, $serialize, $blocking, $errorcode);
$result = \msg_send($queue, $message_type, $message, $serialize, $blocking, $error_code);
if ($result === false) {
throw SemException::createFromPhpError();
}
@@ -176,7 +204,7 @@ function msg_send($queue, int $msgtype, $message, bool $serialize = true, bool $
* root privileges are required to raise the msg_qbytes values above the
* system defined limit.
*
* @param resource $queue Message queue resource handle
* @param resource $queue The message queue.
* @param array $data You specify the values you require by setting the value of the keys
* that you require in the data array.
* @throws SemException
@@ -192,6 +220,100 @@ function msg_set_queue($queue, array $data): void
}
/**
* msg_stat_queue returns the message queue meta data
* for the message queue specified by the queue.
* This is useful, for example, to determine which process sent the message
* that was just received.
*
* @param resource $queue The message queue.
* @return array On success, the return value is an array whose keys and values have the following
* meanings:
*
* Array structure for msg_stat_queue
*
*
*
* msg_perm.uid
*
* The uid of the owner of the queue.
*
*
*
* msg_perm.gid
*
* The gid of the owner of the queue.
*
*
*
* msg_perm.mode
*
* The file access mode of the queue.
*
*
*
* msg_stime
*
* The time that the last message was sent to the queue.
*
*
*
* msg_rtime
*
* The time that the last message was received from the queue.
*
*
*
* msg_ctime
*
* The time that the queue was last changed.
*
*
*
* msg_qnum
*
* The number of messages waiting to be read from the queue.
*
*
*
* msg_qbytes
*
* The maximum number of bytes allowed in one message queue. On
* Linux, this value may be read and modified via
* /proc/sys/kernel/msgmnb.
*
*
*
* msg_lspid
*
* The pid of the process that sent the last message to the queue.
*
*
*
* msg_lrpid
*
* The pid of the process that received the last message from the queue.
*
*
*
*
*
*
* Returns FALSE on failure.
* @throws SemException
*
*/
function msg_stat_queue($queue): array
{
error_clear_last();
$result = \msg_stat_queue($queue);
if ($result === false) {
throw SemException::createFromPhpError();
}
return $result;
}
/**
* sem_acquire by default blocks (if necessary) until the
* semaphore can be acquired. A process attempting to acquire a semaphore which
@@ -202,19 +324,19 @@ function msg_set_queue($queue, array $data): void
* explicitly released will be released automatically and a warning will be
* generated.
*
* @param resource $sem_identifier sem_identifier is a semaphore resource,
* @param resource $semaphore semaphore is a semaphore
* obtained from sem_get.
* @param bool $nowait Specifies if the process shouldn't wait for the semaphore to be acquired.
* @param bool $non_blocking Specifies if the process shouldn't wait for the semaphore to be acquired.
* If set to true, the call will return
* false immediately if a semaphore cannot be immediately
* acquired.
* @throws SemException
*
*/
function sem_acquire($sem_identifier, bool $nowait = false): void
function sem_acquire($semaphore, bool $non_blocking = false): void
{
error_clear_last();
$result = \sem_acquire($sem_identifier, $nowait);
$result = \sem_acquire($semaphore, $non_blocking);
if ($result === false) {
throw SemException::createFromPhpError();
}
@@ -235,19 +357,19 @@ function sem_acquire($sem_identifier, bool $nowait = false): void
* @param int $key
* @param int $max_acquire The number of processes that can acquire the semaphore simultaneously
* is set to max_acquire.
* @param int $perm The semaphore permissions. Actually this value is
* @param int $permissions The semaphore permissions. Actually this value is
* set only if the process finds it is the only process currently
* attached to the semaphore.
* @param int $auto_release Specifies if the semaphore should be automatically released on request
* @param bool $auto_release Specifies if the semaphore should be automatically released on request
* shutdown.
* @return resource Returns a positive semaphore identifier on success.
* @throws SemException
*
*/
function sem_get(int $key, int $max_acquire = 1, int $perm = 0666, int $auto_release = 1)
function sem_get(int $key, int $max_acquire = 1, int $permissions = 0666, bool $auto_release = true)
{
error_clear_last();
$result = \sem_get($key, $max_acquire, $perm, $auto_release);
$result = \sem_get($key, $max_acquire, $permissions, $auto_release);
if ($result === false) {
throw SemException::createFromPhpError();
}
@@ -263,15 +385,15 @@ function sem_get(int $key, int $max_acquire = 1, int $perm = 0666, int $auto_rel
* After releasing the semaphore, sem_acquire
* may be called to re-acquire it.
*
* @param resource $sem_identifier A Semaphore resource handle as returned by
* @param resource $semaphore A Semaphore as returned by
* sem_get.
* @throws SemException
*
*/
function sem_release($sem_identifier): void
function sem_release($semaphore): void
{
error_clear_last();
$result = \sem_release($sem_identifier);
$result = \sem_release($semaphore);
if ($result === false) {
throw SemException::createFromPhpError();
}
@@ -283,15 +405,74 @@ function sem_release($sem_identifier): void
*
* After removing the semaphore, it is no longer accessible.
*
* @param resource $sem_identifier A semaphore resource identifier as returned
* @param resource $semaphore A semaphore as returned
* by sem_get.
* @throws SemException
*
*/
function sem_remove($sem_identifier): void
function sem_remove($semaphore): void
{
error_clear_last();
$result = \sem_remove($sem_identifier);
$result = \sem_remove($semaphore);
if ($result === false) {
throw SemException::createFromPhpError();
}
}
/**
* shm_attach returns an id that can be used to access
* the System V shared memory with the given key, the
* first call creates the shared memory segment with
* size and the optional perm-bits
* permissions.
*
* A second call to shm_attach for the same
* key will return a different SysvSharedMemory
* instance, but both instances access the same underlying
* shared memory. size and
* permissions will be ignored.
*
* @param int $key A numeric shared memory segment ID
* @param int $size The memory size. If not provided, default to the
* sysvshm.init_mem in the php.ini, otherwise 10000
* bytes.
* @param int $permissions The optional permission bits. Default to 0666.
* @return resource Returns a SysvSharedMemory instance on success.
* @throws SemException
*
*/
function shm_attach(int $key, int $size = null, int $permissions = 0666)
{
error_clear_last();
if ($permissions !== 0666) {
$result = \shm_attach($key, $size, $permissions);
} elseif ($size !== null) {
$result = \shm_attach($key, $size);
} else {
$result = \shm_attach($key);
}
if ($result === false) {
throw SemException::createFromPhpError();
}
return $result;
}
/**
* shm_detach disconnects from the shared memory given
* by the shm created by
* shm_attach. Remember, that shared memory still exist
* in the Unix system and the data is still present.
*
* @param resource $shm A shared memory segment obtained from shm_attach.
* @throws SemException
*
*/
function shm_detach($shm): void
{
error_clear_last();
$result = \shm_detach($shm);
if ($result === false) {
throw SemException::createFromPhpError();
}
@@ -300,28 +481,27 @@ function sem_remove($sem_identifier): void
/**
* shm_put_var inserts or updates the
* variable with the given
* variable_key.
* value with the given
* key.
*
* Warnings (E_WARNING level) will be issued if
* shm_identifier is not a valid SysV shared memory
* shm is not a valid SysV shared memory
* index or if there was not enough shared memory remaining to complete your
* request.
*
* @param resource $shm_identifier A shared memory resource handle as returned by
* shm_attach
* @param int $variable_key The variable key.
* @param mixed $variable The variable. All variable types
* @param resource $shm A shared memory segment obtained from shm_attach.
* @param int $key The variable key.
* @param mixed $value The variable. All variable types
* that serialize supports may be used: generally
* this means all types except for resources and some internal objects
* that cannot be serialized.
* @throws SemException
*
*/
function shm_put_var($shm_identifier, int $variable_key, $variable): void
function shm_put_var($shm, int $key, $value): void
{
error_clear_last();
$result = \shm_put_var($shm_identifier, $variable_key, $variable);
$result = \shm_put_var($shm, $key, $value);
if ($result === false) {
throw SemException::createFromPhpError();
}
@@ -329,19 +509,18 @@ function shm_put_var($shm_identifier, int $variable_key, $variable): void
/**
* Removes a variable with a given variable_key
* Removes a variable with a given key
* and frees the occupied memory.
*
* @param resource $shm_identifier The shared memory identifier as returned by
* shm_attach
* @param int $variable_key The variable key.
* @param resource $shm A shared memory segment obtained from shm_attach.
* @param int $key The variable key.
* @throws SemException
*
*/
function shm_remove_var($shm_identifier, int $variable_key): void
function shm_remove_var($shm, int $key): void
{
error_clear_last();
$result = \shm_remove_var($shm_identifier, $variable_key);
$result = \shm_remove_var($shm, $key);
if ($result === false) {
throw SemException::createFromPhpError();
}
@@ -350,17 +529,16 @@ function shm_remove_var($shm_identifier, int $variable_key): void
/**
* shm_remove removes the shared memory
* shm_identifier. All data will be destroyed.
* shm. All data will be destroyed.
*
* @param resource $shm_identifier The shared memory identifier as returned by
* shm_attach
* @param resource $shm A shared memory segment obtained from shm_attach.
* @throws SemException
*
*/
function shm_remove($shm_identifier): void
function shm_remove($shm): void
{
error_clear_last();
$result = \shm_remove($shm_identifier);
$result = \shm_remove($shm);
if ($result === false) {
throw SemException::createFromPhpError();
}