├── generated
    ├── Exceptions
    │   ├── .gitkeep
    │   ├── PsException.php
    │   ├── ApcuException.php
    │   ├── ArrayException.php
    │   ├── Bzip2Exception.php
    │   ├── ComException.php
    │   ├── DirException.php
    │   ├── EioException.php
    │   ├── ExecException.php
    │   ├── FpmException.php
    │   ├── FtpException.php
    │   ├── GmpException.php
    │   ├── GnupgException.php
    │   ├── HashException.php
    │   ├── IbaseException.php
    │   ├── IconvException.php
    │   ├── ImageException.php
    │   ├── ImapException.php
    │   ├── InfoException.php
    │   ├── LdapException.php
    │   ├── LzfException.php
    │   ├── MiscException.php
    │   ├── MysqlException.php
    │   ├── Oci8Exception.php
    │   ├── PcntlException.php
    │   ├── PgsqlException.php
    │   ├── PosixException.php
    │   ├── RrdException.php
    │   ├── SemException.php
    │   ├── ShmopException.php
    │   ├── SolrException.php
    │   ├── SplException.php
    │   ├── Ssh2Exception.php
    │   ├── UodbcException.php
    │   ├── UopzException.php
    │   ├── UrlException.php
    │   ├── VarException.php
    │   ├── XdiffException.php
    │   ├── XmlException.php
    │   ├── YamlException.php
    │   ├── YazException.php
    │   ├── ZipException.php
    │   ├── ZlibException.php
    │   ├── ApacheException.php
    │   ├── CubridException.php
    │   ├── FilterException.php
    │   ├── GettextException.php
    │   ├── IbmDb2Exception.php
    │   ├── InotifyException.php
    │   ├── LibxmlException.php
    │   ├── MysqliException.php
    │   ├── NetworkException.php
    │   ├── OpcacheException.php
    │   ├── PspellException.php
    │   ├── RpminfoException.php
    │   ├── SessionException.php
    │   ├── SocketsException.php
    │   ├── SqlsrvException.php
    │   ├── SsdeepException.php
    │   ├── StreamException.php
    │   ├── StringsException.php
    │   ├── SwooleException.php
    │   ├── XmlrpcException.php
    │   ├── CalendarException.php
    │   ├── ClassobjException.php
    │   ├── DatetimeException.php
    │   ├── ErrorfuncException.php
    │   ├── FileinfoException.php
    │   ├── FilesystemException.php
    │   ├── FunchandException.php
    │   ├── IngresiiException.php
    │   ├── MailparseException.php
    │   ├── MbstringException.php
    │   ├── MysqlndMsException.php
    │   ├── MysqlndQcException.php
    │   ├── OutcontrolException.php
    │   ├── PasswordException.php
    │   ├── ReadlineException.php
    │   └── SimplexmlException.php
    ├── rpminfo.php
    ├── solr.php
    ├── libxml.php
    ├── fpm.php
    ├── mysqli.php
    ├── xmlrpc.php
    ├── rrd.php
    ├── gettext.php
    ├── classobj.php
    ├── var.php
    ├── uopz.php
    ├── lzf.php
    ├── inotify.php
    ├── shmop.php
    ├── funchand.php
    ├── opcache.php
    ├── calendar.php
    ├── json.php
    ├── ssdeep.php
    ├── fileinfo.php
    ├── errorfunc.php
    ├── hash.php
    ├── gmp.php
    ├── bzip2.php
    ├── swoole.php
    ├── iconv.php
    ├── filter.php
    ├── apcu.php
    ├── mysqlndQc.php
    ├── simplexml.php
    ├── xml.php
    ├── mysqlndMs.php
    ├── zip.php
    ├── yaml.php
    ├── mailparse.php
    ├── password.php
    ├── outcontrol.php
    ├── readline.php
    ├── gnupg.php
    ├── dir.php
    ├── spl.php
    ├── pcntl.php
    ├── url.php
    ├── apache.php
    ├── exec.php
    ├── com.php
    └── xdiff.php
├── lib
    ├── Exceptions
    │   ├── SafeExceptionInterface.php
    │   ├── OpensslException.php
    │   ├── JsonException.php
    │   ├── CurlException.php
    │   └── PcreException.php
    ├── DateTime.php
    └── DateTimeImmutable.php
├── deprecated
    ├── Exceptions
    │   ├── ApcException.php
    │   ├── MssqlException.php
    │   ├── StatsException.php
    │   └── LibeventException.php
    ├── functionsList.php
    ├── stats.php
    └── apc.php
├── LICENSE
├── composer.json
└── README.md


/generated/Exceptions/.gitkeep:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/lib/Exceptions/SafeExceptionInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Safe\Exceptions;
 5 | 
 6 | interface SafeExceptionInterface extends \Throwable
 7 | {
 8 | 
 9 | }
10 | 


--------------------------------------------------------------------------------
/lib/Exceptions/OpensslException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Safe\Exceptions;
 5 | 
 6 | class OpensslException extends \Exception implements SafeExceptionInterface
 7 | {
 8 |     public static function createFromPhpError(): self
 9 |     {
10 |         return new self(\openssl_error_string() ?: '', 0);
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/lib/Exceptions/JsonException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Safe\Exceptions;
 5 | 
 6 | class JsonException extends \Exception implements SafeExceptionInterface
 7 | {
 8 |     public static function createFromPhpError(): self
 9 |     {
10 |         return new self(\json_last_error_msg(), \json_last_error());
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/generated/Exceptions/PsException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class PsException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/lib/Exceptions/CurlException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Safe\Exceptions;
 5 | 
 6 | class CurlException extends \Exception implements SafeExceptionInterface
 7 | {
 8 |     /**
 9 |      * @param \CurlHandle $ch
10 |      */
11 |     public static function createFromPhpError($ch): self
12 |     {
13 |         return new self(\curl_error($ch), \curl_errno($ch));
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/deprecated/Exceptions/ApcException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class ApcException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/ApcuException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class ApcuException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/ArrayException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class ArrayException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/Bzip2Exception.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class Bzip2Exception extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/ComException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class ComException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/DirException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class DirException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/EioException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class EioException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/ExecException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class ExecException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/FpmException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class FpmException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/FtpException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class FtpException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/GmpException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class GmpException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/GnupgException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class GnupgException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/HashException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class HashException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/IbaseException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class IbaseException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/IconvException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class IconvException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/ImageException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class ImageException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/ImapException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class ImapException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/InfoException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class InfoException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/LdapException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class LdapException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/LzfException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class LzfException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/MiscException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class MiscException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/MysqlException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class MysqlException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/Oci8Exception.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class Oci8Exception extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/PcntlException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class PcntlException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/PgsqlException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class PgsqlException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/PosixException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class PosixException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/RrdException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class RrdException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/SemException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class SemException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/ShmopException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class ShmopException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/SolrException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class SolrException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/SplException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class SplException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/Ssh2Exception.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class Ssh2Exception extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/UodbcException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class UodbcException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/UopzException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class UopzException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/UrlException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class UrlException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/VarException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class VarException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/XdiffException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class XdiffException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/XmlException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class XmlException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/YamlException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class YamlException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/YazException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class YazException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/ZipException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class ZipException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/ZlibException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class ZlibException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/deprecated/Exceptions/MssqlException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class MssqlException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/deprecated/Exceptions/StatsException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class StatsException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/ApacheException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class ApacheException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/CubridException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class CubridException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/FilterException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class FilterException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/GettextException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class GettextException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/IbmDb2Exception.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class IbmDb2Exception extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/InotifyException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class InotifyException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/LibxmlException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class LibxmlException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/MysqliException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class MysqliException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/NetworkException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class NetworkException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/OpcacheException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class OpcacheException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/PspellException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class PspellException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/RpminfoException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class RpminfoException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/SessionException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class SessionException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/SocketsException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class SocketsException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/SqlsrvException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class SqlsrvException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/SsdeepException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class SsdeepException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/StreamException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class StreamException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/StringsException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class StringsException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/SwooleException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class SwooleException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/XmlrpcException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class XmlrpcException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/deprecated/Exceptions/LibeventException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class LibeventException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/CalendarException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class CalendarException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/ClassobjException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class ClassobjException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/DatetimeException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class DatetimeException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/ErrorfuncException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class ErrorfuncException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/FileinfoException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class FileinfoException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/FilesystemException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class FilesystemException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/FunchandException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class FunchandException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/IngresiiException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class IngresiiException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/MailparseException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class MailparseException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/MbstringException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class MbstringException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/MysqlndMsException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class MysqlndMsException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/MysqlndQcException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class MysqlndQcException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/OutcontrolException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class OutcontrolException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/PasswordException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class PasswordException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/ReadlineException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class ReadlineException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/Exceptions/SimplexmlException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Safe\Exceptions;
 3 | 
 4 | class SimplexmlException extends \ErrorException implements SafeExceptionInterface
 5 | {
 6 |     public static function createFromPhpError(): self
 7 |     {
 8 |         $error = error_get_last();
 9 |         return new self($error['message'] ?? 'An error occured', 0, $error['type'] ?? 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/generated/rpminfo.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\RpminfoException;
 6 | 
 7 | /**
 8 |  * Add an additional retrieved tag in subsequent queries.
 9 |  *
10 |  * @param int $tag One of RPMTAG_* constant, see the rpminfo constants page.
11 |  * @throws RpminfoException
12 |  *
13 |  */
14 | function rpmaddtag(int $tag): void
15 | {
16 |     error_clear_last();
17 |     $result = \rpmaddtag($tag);
18 |     if ($result === false) {
19 |         throw RpminfoException::createFromPhpError();
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/generated/solr.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\SolrException;
 6 | 
 7 | /**
 8 |  * This function returns the current version of the extension as a string.
 9 |  *
10 |  * @return string It returns a string on success.
11 |  * @throws SolrException
12 |  *
13 |  */
14 | function solr_get_version(): string
15 | {
16 |     error_clear_last();
17 |     $result = \solr_get_version();
18 |     if ($result === false) {
19 |         throw SolrException::createFromPhpError();
20 |     }
21 |     return $result;
22 | }
23 | 


--------------------------------------------------------------------------------
/generated/libxml.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\LibxmlException;
 6 | 
 7 | /**
 8 |  * Retrieve last error from libxml.
 9 |  *
10 |  * @return \LibXMLError Returns a LibXMLError object if there is any error in the
11 |  * buffer, FALSE otherwise.
12 |  * @throws LibxmlException
13 |  *
14 |  */
15 | function libxml_get_last_error(): \LibXMLError
16 | {
17 |     error_clear_last();
18 |     $result = \libxml_get_last_error();
19 |     if ($result === false) {
20 |         throw LibxmlException::createFromPhpError();
21 |     }
22 |     return $result;
23 | }
24 | 


--------------------------------------------------------------------------------
/generated/fpm.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\FpmException;
 6 | 
 7 | /**
 8 |  * This function flushes all response data to the client and finishes the
 9 |  * request. This allows for time consuming tasks to be performed without
10 |  * leaving the connection to the client open.
11 |  *
12 |  * @throws FpmException
13 |  *
14 |  */
15 | function fastcgi_finish_request(): void
16 | {
17 |     error_clear_last();
18 |     $result = \fastcgi_finish_request();
19 |     if ($result === false) {
20 |         throw FpmException::createFromPhpError();
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/generated/mysqli.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\MysqliException;
 6 | 
 7 | /**
 8 |  * Returns client per-process statistics.
 9 |  * Available only with mysqlnd.
10 |  *
11 |  * @return array Returns an array with client stats if success, FALSE otherwise.
12 |  * @throws MysqliException
13 |  *
14 |  */
15 | function mysqli_get_client_stats(): array
16 | {
17 |     error_clear_last();
18 |     $result = \mysqli_get_client_stats();
19 |     if ($result === false) {
20 |         throw MysqliException::createFromPhpError();
21 |     }
22 |     return $result;
23 | }
24 | 


--------------------------------------------------------------------------------
/generated/xmlrpc.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\XmlrpcException;
 6 | 
 7 | /**
 8 |  * Sets xmlrpc type, base64 or datetime, for a PHP string value.
 9 |  *
10 |  * @param string|\DateTime $value Value to set the type
11 |  * @param string $type 'base64' or 'datetime'
12 |  * @throws XmlrpcException
13 |  *
14 |  */
15 | function xmlrpc_set_type(&$value, string $type): void
16 | {
17 |     error_clear_last();
18 |     $result = \xmlrpc_set_type($value, $type);
19 |     if ($result === false) {
20 |         throw XmlrpcException::createFromPhpError();
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/generated/rrd.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\RrdException;
 6 | 
 7 | /**
 8 |  * Creates the rdd database file.
 9 |  *
10 |  * @param string $filename Filename for newly created rrd file.
11 |  * @param array $options Options for rrd create - list of strings. See man page of rrd create
12 |  * for whole list of options.
13 |  * @throws RrdException
14 |  *
15 |  */
16 | function rrd_create(string $filename, array $options): void
17 | {
18 |     error_clear_last();
19 |     $result = \rrd_create($filename, $options);
20 |     if ($result === false) {
21 |         throw RrdException::createFromPhpError();
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/generated/gettext.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\GettextException;
 6 | 
 7 | /**
 8 |  * The bindtextdomain function sets or gets the path
 9 |  * for a domain.
10 |  *
11 |  * @param string $domain The domain.
12 |  * @param string $directory The directory path.
13 |  * If NULL, the currently set directory is returned.
14 |  * @return string The full pathname for the domain currently being set.
15 |  * @throws GettextException
16 |  *
17 |  */
18 | function bindtextdomain(string $domain, string $directory): string
19 | {
20 |     error_clear_last();
21 |     $result = \bindtextdomain($domain, $directory);
22 |     if ($result === false) {
23 |         throw GettextException::createFromPhpError();
24 |     }
25 |     return $result;
26 | }
27 | 


--------------------------------------------------------------------------------
/generated/classobj.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\ClassobjException;
 6 | 
 7 | /**
 8 |  * Creates an alias named alias
 9 |  * based on the user defined class original.
10 |  * The aliased class is exactly the same as the original class.
11 |  *
12 |  * @param string $original The original class.
13 |  * @param string $alias The alias name for the class.
14 |  * @param bool $autoload Whether to autoload if the original class is not found.
15 |  * @throws ClassobjException
16 |  *
17 |  */
18 | function class_alias(string $original, string $alias, bool $autoload = true): void
19 | {
20 |     error_clear_last();
21 |     $result = \class_alias($original, $alias, $autoload);
22 |     if ($result === false) {
23 |         throw ClassobjException::createFromPhpError();
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/generated/var.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\VarException;
 6 | 
 7 | /**
 8 |  * Set the type of variable var to
 9 |  * type.
10 |  *
11 |  * @param mixed $var The variable being converted.
12 |  * @param string $type Possibles values of type are:
13 |  *
14 |  *
15 |  *
16 |  * "boolean" or "bool"
17 |  *
18 |  *
19 |  *
20 |  *
21 |  * "integer" or "int"
22 |  *
23 |  *
24 |  *
25 |  *
26 |  * "float" or "double"
27 |  *
28 |  *
29 |  *
30 |  *
31 |  * "string"
32 |  *
33 |  *
34 |  *
35 |  *
36 |  * "array"
37 |  *
38 |  *
39 |  *
40 |  *
41 |  * "object"
42 |  *
43 |  *
44 |  *
45 |  *
46 |  * "null"
47 |  *
48 |  *
49 |  *
50 |  * @throws VarException
51 |  *
52 |  */
53 | function settype(&$var, string $type): void
54 | {
55 |     error_clear_last();
56 |     $result = \settype($var, $type);
57 |     if ($result === false) {
58 |         throw VarException::createFromPhpError();
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/lib/Exceptions/PcreException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Safe\Exceptions;
 5 | 
 6 | class PcreException extends \Exception implements SafeExceptionInterface
 7 | {
 8 |     public static function createFromPhpError(): self
 9 |     {
10 |         $errorMap = [
11 |             PREG_INTERNAL_ERROR => 'PREG_INTERNAL_ERROR: Internal error',
12 |             PREG_BACKTRACK_LIMIT_ERROR => 'PREG_BACKTRACK_LIMIT_ERROR: Backtrack limit reached',
13 |             PREG_RECURSION_LIMIT_ERROR => 'PREG_RECURSION_LIMIT_ERROR: Recursion limit reached',
14 |             PREG_BAD_UTF8_ERROR => 'PREG_BAD_UTF8_ERROR: Invalid UTF8 character',
15 |             PREG_BAD_UTF8_OFFSET_ERROR => 'PREG_BAD_UTF8_OFFSET_ERROR',
16 |             PREG_JIT_STACKLIMIT_ERROR => 'PREG_JIT_STACKLIMIT_ERROR',
17 |         ];
18 |         $errMsg = $errorMap[preg_last_error()] ?? 'Unknown PCRE error: '.preg_last_error();
19 |         return new self($errMsg, \preg_last_error());
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/generated/uopz.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\UopzException;
 6 | 
 7 | /**
 8 |  * Makes class extend parent
 9 |  *
10 |  * @param string $class The name of the class to extend
11 |  * @param string $parent The name of the class to inherit
12 |  * @throws UopzException
13 |  *
14 |  */
15 | function uopz_extend(string $class, string $parent): void
16 | {
17 |     error_clear_last();
18 |     $result = \uopz_extend($class, $parent);
19 |     if ($result === false) {
20 |         throw UopzException::createFromPhpError();
21 |     }
22 | }
23 | 
24 | 
25 | /**
26 |  * Makes class implement interface
27 |  *
28 |  * @param string $class
29 |  * @param string $interface
30 |  * @throws UopzException
31 |  *
32 |  */
33 | function uopz_implement(string $class, string $interface): void
34 | {
35 |     error_clear_last();
36 |     $result = \uopz_implement($class, $interface);
37 |     if ($result === false) {
38 |         throw UopzException::createFromPhpError();
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/generated/lzf.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\LzfException;
 6 | 
 7 | /**
 8 |  * lzf_compress compresses the given
 9 |  * data string using LZF encoding.
10 |  *
11 |  * @param string $data The string to compress.
12 |  * @return string Returns the compressed data.
13 |  * @throws LzfException
14 |  *
15 |  */
16 | function lzf_compress(string $data): string
17 | {
18 |     error_clear_last();
19 |     $result = \lzf_compress($data);
20 |     if ($result === false) {
21 |         throw LzfException::createFromPhpError();
22 |     }
23 |     return $result;
24 | }
25 | 
26 | 
27 | /**
28 |  * lzf_compress decompresses the given
29 |  * data string containing lzf encoded data.
30 |  *
31 |  * @param string $data The compressed string.
32 |  * @return string Returns the decompressed data.
33 |  * @throws LzfException
34 |  *
35 |  */
36 | function lzf_decompress(string $data): string
37 | {
38 |     error_clear_last();
39 |     $result = \lzf_decompress($data);
40 |     if ($result === false) {
41 |         throw LzfException::createFromPhpError();
42 |     }
43 |     return $result;
44 | }
45 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018 TheCodingMachine
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.


--------------------------------------------------------------------------------
/generated/inotify.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\InotifyException;
 6 | 
 7 | /**
 8 |  * Initialize an inotify instance for use with
 9 |  * inotify_add_watch
10 |  *
11 |  * @return resource A stream resource.
12 |  * @throws InotifyException
13 |  *
14 |  */
15 | function inotify_init()
16 | {
17 |     error_clear_last();
18 |     $result = \inotify_init();
19 |     if ($result === false) {
20 |         throw InotifyException::createFromPhpError();
21 |     }
22 |     return $result;
23 | }
24 | 
25 | 
26 | /**
27 |  * inotify_rm_watch removes the watch
28 |  * watch_descriptor from the inotify instance
29 |  * inotify_instance.
30 |  *
31 |  * @param resource $inotify_instance Resource returned by
32 |  * inotify_init
33 |  * @param int $watch_descriptor Watch to remove from the instance
34 |  * @throws InotifyException
35 |  *
36 |  */
37 | function inotify_rm_watch($inotify_instance, int $watch_descriptor): void
38 | {
39 |     error_clear_last();
40 |     $result = \inotify_rm_watch($inotify_instance, $watch_descriptor);
41 |     if ($result === false) {
42 |         throw InotifyException::createFromPhpError();
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/generated/shmop.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\ShmopException;
 6 | 
 7 | /**
 8 |  * shmop_delete is used to delete a shared memory block.
 9 |  *
10 |  * @param resource $shmop The shared memory block resource created by
11 |  * shmop_open
12 |  * @throws ShmopException
13 |  *
14 |  */
15 | function shmop_delete($shmop): void
16 | {
17 |     error_clear_last();
18 |     $result = \shmop_delete($shmop);
19 |     if ($result === false) {
20 |         throw ShmopException::createFromPhpError();
21 |     }
22 | }
23 | 
24 | 
25 | /**
26 |  * shmop_read will read a string from shared memory block.
27 |  *
28 |  * @param resource $shmop The shared memory block identifier created by
29 |  * shmop_open
30 |  * @param int $offset Offset from which to start reading
31 |  * @param int $size The number of bytes to read.
32 |  * 0 reads shmop_size($shmid) - $start bytes.
33 |  * @return string Returns the data.
34 |  * @throws ShmopException
35 |  *
36 |  */
37 | function shmop_read($shmop, int $offset, int $size): string
38 | {
39 |     error_clear_last();
40 |     $result = \shmop_read($shmop, $offset, $size);
41 |     if ($result === false) {
42 |         throw ShmopException::createFromPhpError();
43 |     }
44 |     return $result;
45 | }
46 | 


--------------------------------------------------------------------------------
/generated/funchand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\FunchandException;
 6 | 
 7 | /**
 8 |  * Creates an anonymous function from the parameters passed, and
 9 |  * returns a unique name for it.
10 |  *
11 |  * @param string $args The function arguments.
12 |  * @param string $code The function code.
13 |  * @return string Returns a unique function name as a string.
14 |  * @throws FunchandException
15 |  *
16 |  */
17 | function create_function(string $args, string $code): string
18 | {
19 |     error_clear_last();
20 |     $result = \create_function($args, $code);
21 |     if ($result === false) {
22 |         throw FunchandException::createFromPhpError();
23 |     }
24 |     return $result;
25 | }
26 | 
27 | 
28 | /**
29 |  *
30 |  *
31 |  * @param callable(): void $callback The function to register.
32 |  * @param mixed $args
33 |  * @throws FunchandException
34 |  *
35 |  */
36 | function register_tick_function(callable $callback, ...$args): void
37 | {
38 |     error_clear_last();
39 |     if ($args !== []) {
40 |         $result = \register_tick_function($callback, ...$args);
41 |     } else {
42 |         $result = \register_tick_function($callback);
43 |     }
44 |     if ($result === false) {
45 |         throw FunchandException::createFromPhpError();
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/generated/opcache.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\OpcacheException;
 6 | 
 7 | /**
 8 |  * This function compiles a PHP script and adds it to the opcode cache without
 9 |  * executing it. This can be used to prime the cache after a Web server
10 |  * restart by pre-caching files that will be included in later requests.
11 |  *
12 |  * @param string $filename The path to the PHP script to be compiled.
13 |  * @throws OpcacheException
14 |  *
15 |  */
16 | function opcache_compile_file(string $filename): void
17 | {
18 |     error_clear_last();
19 |     $result = \opcache_compile_file($filename);
20 |     if ($result === false) {
21 |         throw OpcacheException::createFromPhpError();
22 |     }
23 | }
24 | 
25 | 
26 | /**
27 |  * This function returns state information about the cache instance
28 |  *
29 |  * @param bool $include_scripts Include script specific state information
30 |  * @return array Returns an array of information, optionally containing script specific state information.
31 |  * @throws OpcacheException
32 |  *
33 |  */
34 | function opcache_get_status(bool $include_scripts = true): array
35 | {
36 |     error_clear_last();
37 |     $result = \opcache_get_status($include_scripts);
38 |     if ($result === false) {
39 |         throw OpcacheException::createFromPhpError();
40 |     }
41 |     return $result;
42 | }
43 | 


--------------------------------------------------------------------------------
/deprecated/functionsList.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 |     'apc_cache_info',
 5 |     'apc_cas',
 6 |     'apc_compile_file',
 7 |     'apc_dec',
 8 |     'apc_define_constants',
 9 |     'apc_delete',
10 |     'apc_delete_file',
11 |     'apc_inc',
12 |     'apc_load_constants',
13 |     'apc_sma_info',
14 |     'event_add',
15 |     'event_base_loopbreak',
16 |     'event_base_loopexit',
17 |     'event_base_new',
18 |     'event_base_priority_init',
19 |     'event_base_reinit',
20 |     'event_base_set',
21 |     'event_buffer_base_set',
22 |     'event_buffer_disable',
23 |     'event_buffer_enable',
24 |     'event_buffer_new',
25 |     'event_buffer_priority_set',
26 |     'event_buffer_set_callback',
27 |     'event_buffer_write',
28 |     'event_del',
29 |     'event_new',
30 |     'event_priority_set',
31 |     'event_set',
32 |     'event_timer_set',
33 |     'imagepsencodefont',
34 |     'imagepsextendfont',
35 |     'imagepsfreefont',
36 |     'imagepsslantfont',
37 |     'mssql_bind',
38 |     'mssql_close',
39 |     'mssql_connect',
40 |     'mssql_data_seek',
41 |     'mssql_field_length',
42 |     'mssql_field_name',
43 |     'mssql_field_seek',
44 |     'mssql_field_type',
45 |     'mssql_free_result',
46 |     'mssql_free_statement',
47 |     'mssql_init',
48 |     'mssql_pconnect',
49 |     'mssql_query',
50 |     'mssql_select_db',
51 |     'stats_covariance',
52 |     'stats_standard_deviation',
53 |     'stats_stat_correlation',
54 |     'stats_stat_innerproduct',
55 |     'stats_variance',
56 | ];
57 | 


--------------------------------------------------------------------------------
/generated/calendar.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\CalendarException;
 6 | 
 7 | /**
 8 |  * This function will return a Unix timestamp corresponding to the
 9 |  * Julian Day given in julian_day. The time returned is
10 |  * UTC.
11 |  *
12 |  * @param int $julian_day A julian day number between 2440588 and 106751993607888
13 |  * on 64bit systems, or between 2440588 and 2465443 on 32bit systems.
14 |  * @return int The unix timestamp for the start (midnight, not noon) of the given Julian day
15 |  * @throws CalendarException
16 |  *
17 |  */
18 | function jdtounix(int $julian_day): int
19 | {
20 |     error_clear_last();
21 |     $result = \jdtounix($julian_day);
22 |     if ($result === false) {
23 |         throw CalendarException::createFromPhpError();
24 |     }
25 |     return $result;
26 | }
27 | 
28 | 
29 | /**
30 |  * Return the Julian Day for a Unix timestamp
31 |  * (seconds since 1.1.1970), or for the current day if no
32 |  * timestamp is given. Either way, the time is regarded
33 |  * as local time (not UTC).
34 |  *
35 |  * @param int $timestamp A unix timestamp to convert.
36 |  * @return int A julian day number as integer.
37 |  * @throws CalendarException
38 |  *
39 |  */
40 | function unixtojd(int $timestamp = null): int
41 | {
42 |     error_clear_last();
43 |     if ($timestamp !== null) {
44 |         $result = \unixtojd($timestamp);
45 |     } else {
46 |         $result = \unixtojd();
47 |     }
48 |     if ($result === false) {
49 |         throw CalendarException::createFromPhpError();
50 |     }
51 |     return $result;
52 | }
53 | 


--------------------------------------------------------------------------------
/generated/json.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\JsonException;
 6 | 
 7 | /**
 8 |  * Returns a string containing the JSON representation of the supplied
 9 |  * value.
10 |  *
11 |  * The encoding is affected by the supplied flags
12 |  * and additionally the encoding of float values depends on the value of
13 |  * serialize_precision.
14 |  *
15 |  * @param mixed $value The value being encoded. Can be any type except
16 |  * a resource.
17 |  *
18 |  * All string data must be UTF-8 encoded.
19 |  *
20 |  * PHP implements a superset of JSON as specified in the original
21 |  * RFC 7159.
22 |  * @param int $flags Bitmask consisting of
23 |  * JSON_FORCE_OBJECT,
24 |  * JSON_HEX_QUOT,
25 |  * JSON_HEX_TAG,
26 |  * JSON_HEX_AMP,
27 |  * JSON_HEX_APOS,
28 |  * JSON_INVALID_UTF8_IGNORE,
29 |  * JSON_INVALID_UTF8_SUBSTITUTE,
30 |  * JSON_NUMERIC_CHECK,
31 |  * JSON_PARTIAL_OUTPUT_ON_ERROR,
32 |  * JSON_PRESERVE_ZERO_FRACTION,
33 |  * JSON_PRETTY_PRINT,
34 |  * JSON_UNESCAPED_LINE_TERMINATORS,
35 |  * JSON_UNESCAPED_SLASHES,
36 |  * JSON_UNESCAPED_UNICODE,
37 |  * JSON_THROW_ON_ERROR.
38 |  * The behaviour of these constants is described on the
39 |  * JSON constants page.
40 |  * @param int $depth Set the maximum depth. Must be greater than zero.
41 |  * @return string Returns a JSON encoded string on success.
42 |  * @throws JsonException
43 |  *
44 |  */
45 | function json_encode($value, int $flags = 0, int $depth = 512): string
46 | {
47 |     error_clear_last();
48 |     $result = \json_encode($value, $flags, $depth);
49 |     if ($result === false) {
50 |         throw JsonException::createFromPhpError();
51 |     }
52 |     return $result;
53 | }
54 | 


--------------------------------------------------------------------------------
/generated/ssdeep.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\SsdeepException;
 6 | 
 7 | /**
 8 |  * Calculates the match score between signature1
 9 |  * and signature2 using
10 |  * context-triggered piecewise hashing, and returns the match
11 |  * score.
12 |  *
13 |  * @param string $signature1 The first fuzzy hash signature string.
14 |  * @param string $signature2 The second fuzzy hash signature string.
15 |  * @return int Returns an integer from 0 to 100 on success, FALSE otherwise.
16 |  * @throws SsdeepException
17 |  *
18 |  */
19 | function ssdeep_fuzzy_compare(string $signature1, string $signature2): int
20 | {
21 |     error_clear_last();
22 |     $result = \ssdeep_fuzzy_compare($signature1, $signature2);
23 |     if ($result === false) {
24 |         throw SsdeepException::createFromPhpError();
25 |     }
26 |     return $result;
27 | }
28 | 
29 | 
30 | /**
31 |  * ssdeep_fuzzy_hash_filename calculates the hash
32 |  * of the file specified by file_name using
33 |  * context-triggered piecewise
34 |  * hashing, and returns that hash.
35 |  *
36 |  * @param string $file_name The filename of the file to hash.
37 |  * @return string Returns a string on success, FALSE otherwise.
38 |  * @throws SsdeepException
39 |  *
40 |  */
41 | function ssdeep_fuzzy_hash_filename(string $file_name): string
42 | {
43 |     error_clear_last();
44 |     $result = \ssdeep_fuzzy_hash_filename($file_name);
45 |     if ($result === false) {
46 |         throw SsdeepException::createFromPhpError();
47 |     }
48 |     return $result;
49 | }
50 | 
51 | 
52 | /**
53 |  * ssdeep_fuzzy_hash calculates the hash of
54 |  * to_hash using
55 |  * context-triggered piecewise hashing, and returns that hash.
56 |  *
57 |  * @param string $to_hash The input string.
58 |  * @return string Returns a string on success, FALSE otherwise.
59 |  * @throws SsdeepException
60 |  *
61 |  */
62 | function ssdeep_fuzzy_hash(string $to_hash): string
63 | {
64 |     error_clear_last();
65 |     $result = \ssdeep_fuzzy_hash($to_hash);
66 |     if ($result === false) {
67 |         throw SsdeepException::createFromPhpError();
68 |     }
69 |     return $result;
70 | }
71 | 


--------------------------------------------------------------------------------
/generated/fileinfo.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\FileinfoException;
 6 | 
 7 | /**
 8 |  * This function closes the resource opened by finfo_open.
 9 |  *
10 |  * @param resource $finfo Fileinfo resource returned by finfo_open.
11 |  * @throws FileinfoException
12 |  *
13 |  */
14 | function finfo_close($finfo): void
15 | {
16 |     error_clear_last();
17 |     $result = \finfo_close($finfo);
18 |     if ($result === false) {
19 |         throw FileinfoException::createFromPhpError();
20 |     }
21 | }
22 | 
23 | 
24 | /**
25 |  * Procedural style
26 |  *
27 |  * Object oriented style (constructor):
28 |  *
29 |  * This function opens a magic database and returns its resource.
30 |  *
31 |  * @param int $flags One or disjunction of more Fileinfo
32 |  * constants.
33 |  * @param string $magic_database Name of a magic database file, usually something like
34 |  * /path/to/magic.mime. If not specified, the
35 |  * MAGIC environment variable is used. If the
36 |  * environment variable isn't set, then PHP's bundled magic database will
37 |  * be used.
38 |  *
39 |  * Passing NULL or an empty string will be equivalent to the default
40 |  * value.
41 |  * @return resource (Procedural style only)
42 |  * Returns a magic database resource on success.
43 |  * @throws FileinfoException
44 |  *
45 |  */
46 | function finfo_open(int $flags = FILEINFO_NONE, string $magic_database = "")
47 | {
48 |     error_clear_last();
49 |     $result = \finfo_open($flags, $magic_database);
50 |     if ($result === false) {
51 |         throw FileinfoException::createFromPhpError();
52 |     }
53 |     return $result;
54 | }
55 | 
56 | 
57 | /**
58 |  * Returns the MIME content type for a file as determined by using
59 |  * information from the magic.mime file.
60 |  *
61 |  * @param string|resource $filename Path to the tested file.
62 |  * @return string Returns the content type in MIME format, like
63 |  * text/plain or application/octet-stream.
64 |  * @throws FileinfoException
65 |  *
66 |  */
67 | function mime_content_type($filename): string
68 | {
69 |     error_clear_last();
70 |     $result = \mime_content_type($filename);
71 |     if ($result === false) {
72 |         throw FileinfoException::createFromPhpError();
73 |     }
74 |     return $result;
75 | }
76 | 


--------------------------------------------------------------------------------
/generated/errorfunc.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\ErrorfuncException;
 6 | 
 7 | /**
 8 |  * Sends an error message to the web server's error log or to a file.
 9 |  *
10 |  * @param string $message The error message that should be logged.
11 |  * @param int $message_type Says where the error should go. The possible message types are as
12 |  * follows:
13 |  *
14 |  *
15 |  * error_log log types
16 |  *
17 |  *
18 |  *
19 |  * 0
20 |  *
21 |  * message is sent to PHP's system logger, using
22 |  * the Operating System's system logging mechanism or a file, depending
23 |  * on what the error_log
24 |  * configuration directive is set to.  This is the default option.
25 |  *
26 |  *
27 |  *
28 |  * 1
29 |  *
30 |  * message is sent by email to the address in
31 |  * the destination parameter.  This is the only
32 |  * message type where the fourth parameter,
33 |  * extra_headers is used.
34 |  *
35 |  *
36 |  *
37 |  * 2
38 |  *
39 |  * No longer an option.
40 |  *
41 |  *
42 |  *
43 |  * 3
44 |  *
45 |  * message is appended to the file
46 |  * destination. A newline is not automatically
47 |  * added to the end of the message string.
48 |  *
49 |  *
50 |  *
51 |  * 4
52 |  *
53 |  * message is sent directly to the SAPI logging
54 |  * handler.
55 |  *
56 |  *
57 |  *
58 |  *
59 |  *
60 |  * @param string $destination The destination. Its meaning depends on the
61 |  * message_type parameter as described above.
62 |  * @param string $extra_headers The extra headers. It's used when the message_type
63 |  * parameter is set to 1.
64 |  * This message type uses the same internal function as
65 |  * mail does.
66 |  * @throws ErrorfuncException
67 |  *
68 |  */
69 | function error_log(string $message, int $message_type = 0, string $destination = null, string $extra_headers = null): void
70 | {
71 |     error_clear_last();
72 |     if ($extra_headers !== null) {
73 |         $result = \error_log($message, $message_type, $destination, $extra_headers);
74 |     } elseif ($destination !== null) {
75 |         $result = \error_log($message, $message_type, $destination);
76 |     } else {
77 |         $result = \error_log($message, $message_type);
78 |     }
79 |     if ($result === false) {
80 |         throw ErrorfuncException::createFromPhpError();
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/generated/hash.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\HashException;
 6 | 
 7 | /**
 8 |  *
 9 |  *
10 |  * @param string $algo Name of selected hashing algorithm (i.e. "sha256", "sha512", "haval160,4", etc..)
11 |  * See hash_algos for a list of supported algorithms.
12 |  *
13 |  *
14 |  * Non-cryptographic hash functions are not allowed.
15 |  *
16 |  *
17 |  *
18 |  * Non-cryptographic hash functions are not allowed.
19 |  * @param string $key Input keying material (raw binary). Cannot be empty.
20 |  * @param int $length Desired output length in bytes.
21 |  * Cannot be greater than 255 times the chosen hash function size.
22 |  *
23 |  * If length is 0, the output length
24 |  * will default to the chosen hash function size.
25 |  * @param string $info Application/context-specific info string.
26 |  * @param string $salt Salt to use during derivation.
27 |  *
28 |  * While optional, adding random salt significantly improves the strength of HKDF.
29 |  * @return string Returns a string containing a raw binary representation of the derived key
30 |  * (also known as output keying material - OKM);.
31 |  * @throws HashException
32 |  *
33 |  */
34 | function hash_hkdf(string $algo, string $key, int $length = 0, string $info = "", string $salt = ""): string
35 | {
36 |     error_clear_last();
37 |     $result = \hash_hkdf($algo, $key, $length, $info, $salt);
38 |     if ($result === false) {
39 |         throw HashException::createFromPhpError();
40 |     }
41 |     return $result;
42 | }
43 | 
44 | 
45 | /**
46 |  *
47 |  *
48 |  * @param \HashContext $context Hashing context returned by hash_init.
49 |  * @param string $filename URL describing location of file to be hashed; Supports fopen wrappers.
50 |  * @param \HashContext|null $stream_context Stream context as returned by stream_context_create.
51 |  * @throws HashException
52 |  *
53 |  */
54 | function hash_update_file(\HashContext $context, string $filename, ?\HashContext $stream_context = null): void
55 | {
56 |     error_clear_last();
57 |     if ($stream_context !== null) {
58 |         $result = \hash_update_file($context, $filename, $stream_context);
59 |     } else {
60 |         $result = \hash_update_file($context, $filename);
61 |     }
62 |     if ($result === false) {
63 |         throw HashException::createFromPhpError();
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/generated/gmp.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\GmpException;
 6 | 
 7 | /**
 8 |  * Calculates the binomial coefficient C(n, k).
 9 |  *
10 |  * @param \GMP|string|int $n A GMP object, an integer or a numeric string.
11 |  * @param int $k
12 |  * @return \GMP Returns the binomial coefficient C(n, k).
13 |  * @throws GmpException
14 |  *
15 |  */
16 | function gmp_binomial($n, int $k): \GMP
17 | {
18 |     error_clear_last();
19 |     $result = \gmp_binomial($n, $k);
20 |     if ($result === false) {
21 |         throw GmpException::createFromPhpError();
22 |     }
23 |     return $result;
24 | }
25 | 
26 | 
27 | /**
28 |  * Export a GMP number to a binary string
29 |  *
30 |  * @param \GMP|string|int $num The GMP number being exported
31 |  * @param int $word_size Default value is 1. The number of bytes in each chunk of binary data. This is mainly used in conjunction with the options parameter.
32 |  * @param int $flags Default value is GMP_MSW_FIRST | GMP_NATIVE_ENDIAN.
33 |  * @return string Returns a string.
34 |  * @throws GmpException
35 |  *
36 |  */
37 | function gmp_export($num, int $word_size = 1, int $flags = GMP_MSW_FIRST | GMP_NATIVE_ENDIAN): string
38 | {
39 |     error_clear_last();
40 |     $result = \gmp_export($num, $word_size, $flags);
41 |     if ($result === false) {
42 |         throw GmpException::createFromPhpError();
43 |     }
44 |     return $result;
45 | }
46 | 
47 | 
48 | /**
49 |  * Import a GMP number from a binary string
50 |  *
51 |  * @param string $data The binary string being imported
52 |  * @param int $word_size Default value is 1. The number of bytes in each chunk of binary data. This is mainly used in conjunction with the options parameter.
53 |  * @param int $flags Default value is GMP_MSW_FIRST | GMP_NATIVE_ENDIAN.
54 |  * @return \GMP Returns a GMP number.
55 |  * @throws GmpException
56 |  *
57 |  */
58 | function gmp_import(string $data, int $word_size = 1, int $flags = GMP_MSW_FIRST | GMP_NATIVE_ENDIAN): \GMP
59 | {
60 |     error_clear_last();
61 |     $result = \gmp_import($data, $word_size, $flags);
62 |     if ($result === false) {
63 |         throw GmpException::createFromPhpError();
64 |     }
65 |     return $result;
66 | }
67 | 
68 | 
69 | /**
70 |  *
71 |  *
72 |  * @param \GMP|string|int $seed The seed to be set for the gmp_random,
73 |  * gmp_random_bits, and
74 |  * gmp_random_range functions.
75 |  *
76 |  * A GMP object, an integer or a numeric string.
77 |  * @throws GmpException
78 |  *
79 |  */
80 | function gmp_random_seed($seed): void
81 | {
82 |     error_clear_last();
83 |     $result = \gmp_random_seed($seed);
84 |     if ($result === false) {
85 |         throw GmpException::createFromPhpError();
86 |     }
87 | }
88 | 


--------------------------------------------------------------------------------
/lib/DateTime.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use DateInterval;
 6 | use DateTimeInterface;
 7 | use DateTimeZone;
 8 | use Safe\Exceptions\DatetimeException;
 9 | 
10 | /** this class implements a safe version of the Datetime class */
11 | class DateTime extends \DateTime
12 | {
13 |     //switch from regular datetime to safe version
14 |     private static function createFromRegular(\DateTime $datetime): self
15 |     {
16 |         return new self($datetime->format('Y-m-d H:i:s.u'), $datetime->getTimezone());
17 |     }
18 | 
19 |     /**
20 |      * @param string $format
21 |      * @param string $time
22 |      * @param DateTimeZone|null $timezone
23 |      * @throws DatetimeException
24 |      */
25 |     public static function createFromFormat($format, $time, $timezone = null): self
26 |     {
27 |         $datetime = parent::createFromFormat($format, $time, $timezone);
28 |         if ($datetime === false) {
29 |             throw DatetimeException::createFromPhpError();
30 |         }
31 |         return self::createFromRegular($datetime);
32 |     }
33 | 
34 |     /**
35 |      * @param DateTimeInterface $datetime2 The date to compare to.
36 |      * @param boolean $absolute [optional] Whether to return absolute difference.
37 |      * @return DateInterval The DateInterval object representing the difference between the two dates.
38 |      * @throws DatetimeException
39 |      */
40 |     public function diff($datetime2, $absolute = false): DateInterval
41 |     {
42 |         /** @var \DateInterval|false $result */
43 |         $result = parent::diff($datetime2, $absolute);
44 |         if ($result === false) {
45 |             throw DatetimeException::createFromPhpError();
46 |         }
47 |         return $result;
48 |     }
49 | 
50 |     /**
51 |      * @param string $modify A date/time string. Valid formats are explained in <a href="https://secure.php.net/manual/en/datetime.formats.php">Date and Time Formats</a>.
52 |      * @return DateTime Returns the DateTime object for method chaining.
53 |      * @throws DatetimeException
54 |      */
55 |     public function modify($modify): self
56 |     {
57 |         /** @var DateTime|false $result */
58 |         $result = parent::modify($modify);
59 |         if ($result === false) {
60 |             throw DatetimeException::createFromPhpError();
61 |         }
62 |         return $result;
63 |     }
64 | 
65 |     /**
66 |      * @param int $year
67 |      * @param int $month
68 |      * @param int $day
69 |      * @return DateTime
70 |      * @throws DatetimeException
71 |      */
72 |     public function setDate($year, $month, $day): self
73 |     {
74 |         /** @var DateTime|false $result */
75 |         $result = parent::setDate($year, $month, $day);
76 |         if ($result === false) {
77 |             throw DatetimeException::createFromPhpError();
78 |         }
79 |         return $result;
80 |     }
81 | }
82 | 


--------------------------------------------------------------------------------
/generated/bzip2.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\Bzip2Exception;
 6 | 
 7 | /**
 8 |  * Closes the given bzip2 file pointer.
 9 |  *
10 |  * @param resource $bz The file pointer. It must be valid and must point to a file
11 |  * successfully opened by bzopen.
12 |  * @throws Bzip2Exception
13 |  *
14 |  */
15 | function bzclose($bz): void
16 | {
17 |     error_clear_last();
18 |     $result = \bzclose($bz);
19 |     if ($result === false) {
20 |         throw Bzip2Exception::createFromPhpError();
21 |     }
22 | }
23 | 
24 | 
25 | /**
26 |  * This function is supposed to force a write of all buffered bzip2 data for the file pointer
27 |  * bz,
28 |  * but is implemented as null function in libbz2, and as such does nothing.
29 |  *
30 |  * @param resource $bz The file pointer. It must be valid and must point to a file
31 |  * successfully opened by bzopen.
32 |  * @throws Bzip2Exception
33 |  *
34 |  */
35 | function bzflush($bz): void
36 | {
37 |     error_clear_last();
38 |     $result = \bzflush($bz);
39 |     if ($result === false) {
40 |         throw Bzip2Exception::createFromPhpError();
41 |     }
42 | }
43 | 
44 | 
45 | /**
46 |  * bzread reads from the given bzip2 file pointer.
47 |  *
48 |  * Reading stops when length (uncompressed) bytes have
49 |  * been read or EOF is reached, whichever comes first.
50 |  *
51 |  * @param resource $bz The file pointer. It must be valid and must point to a file
52 |  * successfully opened by bzopen.
53 |  * @param int $length If not specified, bzread will read 1024
54 |  * (uncompressed) bytes at a time. A maximum of 8192
55 |  * uncompressed bytes will be read at a time.
56 |  * @return string Returns the uncompressed data.
57 |  * @throws Bzip2Exception
58 |  *
59 |  */
60 | function bzread($bz, int $length = 1024): string
61 | {
62 |     error_clear_last();
63 |     $result = \bzread($bz, $length);
64 |     if ($result === false) {
65 |         throw Bzip2Exception::createFromPhpError();
66 |     }
67 |     return $result;
68 | }
69 | 
70 | 
71 | /**
72 |  * bzwrite writes a string into the given bzip2 file
73 |  * stream.
74 |  *
75 |  * @param resource $bz The file pointer. It must be valid and must point to a file
76 |  * successfully opened by bzopen.
77 |  * @param string $data The written data.
78 |  * @param int $length If supplied, writing will stop after length
79 |  * (uncompressed) bytes have been written or the end of
80 |  * data is reached, whichever comes first.
81 |  * @return int Returns the number of bytes written.
82 |  * @throws Bzip2Exception
83 |  *
84 |  */
85 | function bzwrite($bz, string $data, int $length = null): int
86 | {
87 |     error_clear_last();
88 |     if ($length !== null) {
89 |         $result = \bzwrite($bz, $data, $length);
90 |     } else {
91 |         $result = \bzwrite($bz, $data);
92 |     }
93 |     if ($result === false) {
94 |         throw Bzip2Exception::createFromPhpError();
95 |     }
96 |     return $result;
97 | }
98 | 


--------------------------------------------------------------------------------
/generated/swoole.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Safe;
  4 | 
  5 | use Safe\Exceptions\SwooleException;
  6 | 
  7 | /**
  8 |  *
  9 |  *
 10 |  * @param string $filename The filename being written.
 11 |  * @param string $content The content writing to the file.
 12 |  * @param int $offset The offset.
 13 |  * @param callable $callback
 14 |  * @throws SwooleException
 15 |  *
 16 |  */
 17 | function swoole_async_write(string $filename, string $content, int $offset = null, callable $callback = null): void
 18 | {
 19 |     error_clear_last();
 20 |     if ($callback !== null) {
 21 |         $result = \swoole_async_write($filename, $content, $offset, $callback);
 22 |     } elseif ($offset !== null) {
 23 |         $result = \swoole_async_write($filename, $content, $offset);
 24 |     } else {
 25 |         $result = \swoole_async_write($filename, $content);
 26 |     }
 27 |     if ($result === false) {
 28 |         throw SwooleException::createFromPhpError();
 29 |     }
 30 | }
 31 | 
 32 | 
 33 | /**
 34 |  *
 35 |  *
 36 |  * @param string $filename The filename being written.
 37 |  * @param string $content The content writing to the file.
 38 |  * @param callable $callback
 39 |  * @param int $flags
 40 |  * @throws SwooleException
 41 |  *
 42 |  */
 43 | function swoole_async_writefile(string $filename, string $content, callable $callback = null, int $flags = 0): void
 44 | {
 45 |     error_clear_last();
 46 |     if ($flags !== 0) {
 47 |         $result = \swoole_async_writefile($filename, $content, $callback, $flags);
 48 |     } elseif ($callback !== null) {
 49 |         $result = \swoole_async_writefile($filename, $content, $callback);
 50 |     } else {
 51 |         $result = \swoole_async_writefile($filename, $content);
 52 |     }
 53 |     if ($result === false) {
 54 |         throw SwooleException::createFromPhpError();
 55 |     }
 56 | }
 57 | 
 58 | 
 59 | /**
 60 |  *
 61 |  *
 62 |  * @param callable $callback
 63 |  * @throws SwooleException
 64 |  *
 65 |  */
 66 | function swoole_event_defer(callable $callback): void
 67 | {
 68 |     error_clear_last();
 69 |     $result = \swoole_event_defer($callback);
 70 |     if ($result === false) {
 71 |         throw SwooleException::createFromPhpError();
 72 |     }
 73 | }
 74 | 
 75 | 
 76 | /**
 77 |  *
 78 |  *
 79 |  * @param int $fd
 80 |  * @throws SwooleException
 81 |  *
 82 |  */
 83 | function swoole_event_del(int $fd): void
 84 | {
 85 |     error_clear_last();
 86 |     $result = \swoole_event_del($fd);
 87 |     if ($result === false) {
 88 |         throw SwooleException::createFromPhpError();
 89 |     }
 90 | }
 91 | 
 92 | 
 93 | /**
 94 |  *
 95 |  *
 96 |  * @param int $fd
 97 |  * @param string $data
 98 |  * @throws SwooleException
 99 |  *
100 |  */
101 | function swoole_event_write(int $fd, string $data): void
102 | {
103 |     error_clear_last();
104 |     $result = \swoole_event_write($fd, $data);
105 |     if ($result === false) {
106 |         throw SwooleException::createFromPhpError();
107 |     }
108 | }
109 | 


--------------------------------------------------------------------------------
/generated/iconv.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\IconvException;
 6 | 
 7 | /**
 8 |  * Retrieve internal configuration variables of iconv extension.
 9 |  *
10 |  * @param string $type The value of the optional type can be:
11 |  *
12 |  * all
13 |  * input_encoding
14 |  * output_encoding
15 |  * internal_encoding
16 |  *
17 |  * @return mixed Returns the current value of the internal configuration variable if
18 |  * successful.
19 |  *
20 |  * If type is omitted or set to "all",
21 |  * iconv_get_encoding returns an array that
22 |  * stores all these variables.
23 |  * @throws IconvException
24 |  *
25 |  */
26 | function iconv_get_encoding(string $type = "all")
27 | {
28 |     error_clear_last();
29 |     $result = \iconv_get_encoding($type);
30 |     if ($result === false) {
31 |         throw IconvException::createFromPhpError();
32 |     }
33 |     return $result;
34 | }
35 | 
36 | 
37 | /**
38 |  * Changes the value of the internal configuration variable specified by
39 |  * type to encoding.
40 |  *
41 |  * @param string $type The value of type can be any one of these:
42 |  *
43 |  * input_encoding
44 |  * output_encoding
45 |  * internal_encoding
46 |  *
47 |  * @param string $encoding The character set.
48 |  * @throws IconvException
49 |  *
50 |  */
51 | function iconv_set_encoding(string $type, string $encoding): void
52 | {
53 |     error_clear_last();
54 |     $result = \iconv_set_encoding($type, $encoding);
55 |     if ($result === false) {
56 |         throw IconvException::createFromPhpError();
57 |     }
58 | }
59 | 
60 | 
61 | /**
62 |  * Performs a character set conversion on the string
63 |  * string from from_encoding
64 |  * to to_encoding.
65 |  *
66 |  * @param string $from_encoding The input charset.
67 |  * @param string $to_encoding The output charset.
68 |  *
69 |  * If you append the string //TRANSLIT to
70 |  * to_encoding transliteration is activated. This
71 |  * means that when a character can't be represented in the target charset,
72 |  * it can be approximated through one or several similarly looking
73 |  * characters. If you append the string //IGNORE,
74 |  * characters that cannot be represented in the target charset are silently
75 |  * discarded. Otherwise, E_NOTICE is generated and the function
76 |  * will return FALSE.
77 |  *
78 |  * If and how //TRANSLIT works exactly depends on the
79 |  * system's iconv() implementation (cf. ICONV_IMPL).
80 |  * Some implementations are known to ignore //TRANSLIT,
81 |  * so the conversion is likely to fail for characters which are illegal for
82 |  * the to_encoding.
83 |  * @param string $string The string to be converted.
84 |  * @return string Returns the converted string.
85 |  * @throws IconvException
86 |  *
87 |  */
88 | function iconv(string $from_encoding, string $to_encoding, string $string): string
89 | {
90 |     error_clear_last();
91 |     $result = \iconv($from_encoding, $to_encoding, $string);
92 |     if ($result === false) {
93 |         throw IconvException::createFromPhpError();
94 |     }
95 |     return $result;
96 | }
97 | 


--------------------------------------------------------------------------------
/deprecated/stats.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Safe;
  4 | 
  5 | use Safe\Exceptions\StatsException;
  6 | 
  7 | /**
  8 |  * Returns the covariance of a and b.
  9 |  *
 10 |  * @param array $a The first array
 11 |  * @param array $b The second array
 12 |  * @return float Returns the covariance of a and b.
 13 |  * @throws StatsException
 14 |  *
 15 |  */
 16 | function stats_covariance(array $a, array $b): float
 17 | {
 18 |     error_clear_last();
 19 |     $result = \stats_covariance($a, $b);
 20 |     if ($result === false) {
 21 |         throw StatsException::createFromPhpError();
 22 |     }
 23 |     return $result;
 24 | }
 25 | 
 26 | 
 27 | /**
 28 |  * Returns the standard deviation of the values in a.
 29 |  *
 30 |  * @param array $a The array of data to find the standard deviation for. Note that all
 31 |  * values of the array will be cast to float.
 32 |  * @param bool $sample Indicates if a represents a sample of the
 33 |  * population; defaults to FALSE.
 34 |  * @return float Returns the standard deviation on success; FALSE on failure.
 35 |  * @throws StatsException
 36 |  *
 37 |  */
 38 | function stats_standard_deviation(array $a, bool $sample = false): float
 39 | {
 40 |     error_clear_last();
 41 |     $result = \stats_standard_deviation($a, $sample);
 42 |     if ($result === false) {
 43 |         throw StatsException::createFromPhpError();
 44 |     }
 45 |     return $result;
 46 | }
 47 | 
 48 | 
 49 | /**
 50 |  * Returns the Pearson correlation coefficient between arr1 and arr2.
 51 |  *
 52 |  * @param array $arr1 The first array
 53 |  * @param array $arr2 The second array
 54 |  * @return float Returns the Pearson correlation coefficient between arr1 and arr2.
 55 |  * @throws StatsException
 56 |  *
 57 |  */
 58 | function stats_stat_correlation(array $arr1, array $arr2): float
 59 | {
 60 |     error_clear_last();
 61 |     $result = \stats_stat_correlation($arr1, $arr2);
 62 |     if ($result === false) {
 63 |         throw StatsException::createFromPhpError();
 64 |     }
 65 |     return $result;
 66 | }
 67 | 
 68 | 
 69 | /**
 70 |  * Returns the inner product of arr1 and arr2.
 71 |  *
 72 |  * @param array $arr1 The first array
 73 |  * @param array $arr2 The second array
 74 |  * @return float Returns the inner product of arr1 and arr2.
 75 |  * @throws StatsException
 76 |  *
 77 |  */
 78 | function stats_stat_innerproduct(array $arr1, array $arr2): float
 79 | {
 80 |     error_clear_last();
 81 |     $result = \stats_stat_innerproduct($arr1, $arr2);
 82 |     if ($result === false) {
 83 |         throw StatsException::createFromPhpError();
 84 |     }
 85 |     return $result;
 86 | }
 87 | 
 88 | 
 89 | /**
 90 |  * Returns the variance of the values in a.
 91 |  *
 92 |  * @param array $a The array of data to find the standard deviation for. Note that all
 93 |  * values of the array will be cast to float.
 94 |  * @param bool $sample Indicates if a represents a sample of the
 95 |  * population; defaults to FALSE.
 96 |  * @return float Returns the variance on success; FALSE on failure.
 97 |  * @throws StatsException
 98 |  *
 99 |  */
100 | function stats_variance(array $a, bool $sample = false): float
101 | {
102 |     error_clear_last();
103 |     $result = \stats_variance($a, $sample);
104 |     if ($result === false) {
105 |         throw StatsException::createFromPhpError();
106 |     }
107 |     return $result;
108 | }
109 | 


--------------------------------------------------------------------------------
/generated/filter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\FilterException;
 6 | 
 7 | /**
 8 |  * This function is useful for retrieving many values without
 9 |  * repetitively calling filter_input.
10 |  *
11 |  * @param int $type One of INPUT_GET, INPUT_POST,
12 |  * INPUT_COOKIE, INPUT_SERVER, or
13 |  * INPUT_ENV.
14 |  * @param int|array $options An array defining the arguments. A valid key is a string
15 |  * containing a variable name and a valid value is either a filter type, or an array
16 |  * optionally specifying the filter, flags and options. If the value is an
17 |  * array, valid keys are filter which specifies the
18 |  * filter type,
19 |  * flags which specifies any flags that apply to the
20 |  * filter, and options which specifies any options that
21 |  * apply to the filter. See the example below for a better understanding.
22 |  *
23 |  * This parameter can be also an integer holding a filter constant. Then all values in the
24 |  * input array are filtered by this filter.
25 |  * @param bool $add_empty Add missing keys as NULL to the return value.
26 |  * @return array|null An array containing the values of the requested variables on success.
27 |  * If the input array designated by type is not populated,
28 |  * the function returns NULL if the FILTER_NULL_ON_FAILURE
29 |  * flag is not given, or FALSE otherwise. For other failures, FALSE is returned.
30 |  *
31 |  * An array value will be FALSE if the filter fails, or NULL if
32 |  * the variable is not set. Or if the flag FILTER_NULL_ON_FAILURE
33 |  * is used, it returns FALSE if the variable is not set and NULL if the filter
34 |  * fails. If the add_empty parameter is FALSE, no array
35 |  * element will be added for unset variables.
36 |  * @throws FilterException
37 |  *
38 |  */
39 | function filter_input_array(int $type, $options = FILTER_DEFAULT, bool $add_empty = true): ?array
40 | {
41 |     error_clear_last();
42 |     $result = \filter_input_array($type, $options, $add_empty);
43 |     if ($result === false) {
44 |         throw FilterException::createFromPhpError();
45 |     }
46 |     return $result;
47 | }
48 | 
49 | 
50 | /**
51 |  * This function is useful for retrieving many values without
52 |  * repetitively calling filter_var.
53 |  *
54 |  * @param array $array An array with string keys containing the data to filter.
55 |  * @param mixed $options An array defining the arguments. A valid key is a string
56 |  * containing a variable name and a valid value is either a
57 |  * filter type, or an
58 |  * array optionally specifying the filter, flags and options.
59 |  * If the value is an array, valid keys are filter
60 |  * which specifies the filter type,
61 |  * flags which specifies any flags that apply to the
62 |  * filter, and options which specifies any options that
63 |  * apply to the filter. See the example below for a better understanding.
64 |  *
65 |  * This parameter can be also an integer holding a filter constant. Then all values in the
66 |  * input array are filtered by this filter.
67 |  * @param bool $add_empty Add missing keys as NULL to the return value.
68 |  * @return array|null An array containing the values of the requested variables on success. An array value will be FALSE if the filter fails, or NULL if
69 |  * the variable is not set.
70 |  * @throws FilterException
71 |  *
72 |  */
73 | function filter_var_array(array $array, $options = FILTER_DEFAULT, bool $add_empty = true): ?array
74 | {
75 |     error_clear_last();
76 |     $result = \filter_var_array($array, $options, $add_empty);
77 |     if ($result === false) {
78 |         throw FilterException::createFromPhpError();
79 |     }
80 |     return $result;
81 | }
82 | 


--------------------------------------------------------------------------------
/generated/apcu.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Safe;
  4 | 
  5 | use Safe\Exceptions\ApcuException;
  6 | 
  7 | /**
  8 |  * Retrieves cached information and meta-data from APC's data store.
  9 |  *
 10 |  * @param bool $limited If limited is TRUE, the
 11 |  * return value will exclude the individual list of cache entries.  This
 12 |  * is useful when trying to optimize calls for statistics gathering.
 13 |  * @return array Array of cached data (and meta-data)
 14 |  * @throws ApcuException
 15 |  *
 16 |  */
 17 | function apcu_cache_info(bool $limited = false): array
 18 | {
 19 |     error_clear_last();
 20 |     $result = \apcu_cache_info($limited);
 21 |     if ($result === false) {
 22 |         throw ApcuException::createFromPhpError();
 23 |     }
 24 |     return $result;
 25 | }
 26 | 
 27 | 
 28 | /**
 29 |  * apcu_cas updates an already existing integer value if the
 30 |  * old parameter matches the currently stored value
 31 |  * with the value of the new parameter.
 32 |  *
 33 |  * @param string $key The key of the value being updated.
 34 |  * @param int $old The old value (the value currently stored).
 35 |  * @param int $new The new value to update to.
 36 |  * @throws ApcuException
 37 |  *
 38 |  */
 39 | function apcu_cas(string $key, int $old, int $new): void
 40 | {
 41 |     error_clear_last();
 42 |     $result = \apcu_cas($key, $old, $new);
 43 |     if ($result === false) {
 44 |         throw ApcuException::createFromPhpError();
 45 |     }
 46 | }
 47 | 
 48 | 
 49 | /**
 50 |  * Decreases a stored integer value.
 51 |  *
 52 |  * @param string $key The key of the value being decreased.
 53 |  * @param int $step The step, or value to decrease.
 54 |  * @param bool|null $success Optionally pass the success or fail boolean value to
 55 |  * this referenced variable.
 56 |  * @param int $ttl TTL to use if the operation inserts a new value (rather than decrementing an existing one).
 57 |  * @return int Returns the current value of key's value on success
 58 |  * @throws ApcuException
 59 |  *
 60 |  */
 61 | function apcu_dec(string $key, int $step = 1, ?bool &$success = null, int $ttl = 0): int
 62 | {
 63 |     error_clear_last();
 64 |     $result = \apcu_dec($key, $step, $success, $ttl);
 65 |     if ($result === false) {
 66 |         throw ApcuException::createFromPhpError();
 67 |     }
 68 |     return $result;
 69 | }
 70 | 
 71 | 
 72 | /**
 73 |  * Increases a stored number.
 74 |  *
 75 |  * @param string $key The key of the value being increased.
 76 |  * @param int $step The step, or value to increase.
 77 |  * @param bool|null $success Optionally pass the success or fail boolean value to
 78 |  * this referenced variable.
 79 |  * @param int $ttl TTL to use if the operation inserts a new value (rather than incrementing an existing one).
 80 |  * @return int Returns the current value of key's value on success
 81 |  * @throws ApcuException
 82 |  *
 83 |  */
 84 | function apcu_inc(string $key, int $step = 1, ?bool &$success = null, int $ttl = 0): int
 85 | {
 86 |     error_clear_last();
 87 |     $result = \apcu_inc($key, $step, $success, $ttl);
 88 |     if ($result === false) {
 89 |         throw ApcuException::createFromPhpError();
 90 |     }
 91 |     return $result;
 92 | }
 93 | 
 94 | 
 95 | /**
 96 |  * Retrieves APCu Shared Memory Allocation information.
 97 |  *
 98 |  * @param bool $limited When set to FALSE (default) apcu_sma_info will
 99 |  * return a detailed information about each segment.
100 |  * @return array Array of Shared Memory Allocation data; FALSE on failure.
101 |  * @throws ApcuException
102 |  *
103 |  */
104 | function apcu_sma_info(bool $limited = false): array
105 | {
106 |     error_clear_last();
107 |     $result = \apcu_sma_info($limited);
108 |     if ($result === false) {
109 |         throw ApcuException::createFromPhpError();
110 |     }
111 |     return $result;
112 | }
113 | 


--------------------------------------------------------------------------------
/generated/mysqlndQc.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Safe;
  4 | 
  5 | use Safe\Exceptions\MysqlndQcException;
  6 | 
  7 | /**
  8 |  * Flush all cache contents.
  9 |  *
 10 |  * Flushing the cache is a storage handler responsibility.
 11 |  * All built-in storage handler but the
 12 |  * memcache storage
 13 |  * handler support flushing the cache. The
 14 |  * memcache
 15 |  * storage handler cannot flush its cache contents.
 16 |  *
 17 |  * User-defined storage handler may or may not support the operation.
 18 |  *
 19 |  * @throws MysqlndQcException
 20 |  *
 21 |  */
 22 | function mysqlnd_qc_clear_cache(): void
 23 | {
 24 |     error_clear_last();
 25 |     $result = \mysqlnd_qc_clear_cache();
 26 |     if ($result === false) {
 27 |         throw MysqlndQcException::createFromPhpError();
 28 |     }
 29 | }
 30 | 
 31 | 
 32 | /**
 33 |  * Installs a callback which decides whether a statement is cached.
 34 |  *
 35 |  * There are several ways of hinting PELC/mysqlnd_qc to cache a query.
 36 |  * By default, PECL/mysqlnd_qc attempts to cache a if caching of all statements
 37 |  * is enabled or the query string begins with a certain SQL hint.
 38 |  * The plugin internally calls a function named is_select()
 39 |  * to find out. This internal function can be replaced with a user-defined callback.
 40 |  * Then, the user-defined callback is responsible to decide whether the plugin
 41 |  * attempts to cache a statement. Because the internal function is replaced
 42 |  * with the callback, the callback gains full control. The callback is free
 43 |  * to ignore the configuration setting mysqlnd_qc.cache_by_default
 44 |  * and SQL hints.
 45 |  *
 46 |  * The callback is invoked for every statement inspected by the plugin.
 47 |  * It is given the statements string as a parameter. The callback returns
 48 |  * FALSE if the statement shall not be cached. It returns TRUE to
 49 |  * make the plugin attempt to cache the statements result set, if any.
 50 |  * A so-created cache entry is given the default TTL set with the
 51 |  * PHP configuration directive mysqlnd_qc.ttl.
 52 |  * If a different TTL shall be used, the callback returns a numeric
 53 |  * value to be used as the TTL.
 54 |  *
 55 |  * The internal is_select function is part of the internal
 56 |  * cache storage handler interface. Thus, a user-defined storage handler
 57 |  * offers the same capabilities.
 58 |  *
 59 |  * @param string $callback
 60 |  * @return mixed Returns TRUE on success.
 61 |  * @throws MysqlndQcException
 62 |  *
 63 |  */
 64 | function mysqlnd_qc_set_is_select(string $callback)
 65 | {
 66 |     error_clear_last();
 67 |     $result = \mysqlnd_qc_set_is_select($callback);
 68 |     if ($result === false) {
 69 |         throw MysqlndQcException::createFromPhpError();
 70 |     }
 71 |     return $result;
 72 | }
 73 | 
 74 | 
 75 | /**
 76 |  * Sets the storage handler used by the query cache. A list of available
 77 |  * storage handler can be obtained from
 78 |  * mysqlnd_qc_get_available_handlers.
 79 |  * Which storage are available depends on the compile time
 80 |  * configuration of the query cache plugin. The
 81 |  * default storage handler is always available.
 82 |  * All other storage handler must be enabled explicitly when building the
 83 |  * extension.
 84 |  *
 85 |  * @param string $handler Handler can be of type string representing the name of a
 86 |  * built-in storage handler or an object of type
 87 |  * mysqlnd_qc_handler_default.
 88 |  * The names of the built-in storage handler are
 89 |  * default,
 90 |  * APC,
 91 |  * MEMCACHE,
 92 |  * sqlite.
 93 |  * @throws MysqlndQcException
 94 |  *
 95 |  */
 96 | function mysqlnd_qc_set_storage_handler(string $handler): void
 97 | {
 98 |     error_clear_last();
 99 |     $result = \mysqlnd_qc_set_storage_handler($handler);
100 |     if ($result === false) {
101 |         throw MysqlndQcException::createFromPhpError();
102 |     }
103 | }
104 | 


--------------------------------------------------------------------------------
/generated/simplexml.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Safe;
 4 | 
 5 | use Safe\Exceptions\SimplexmlException;
 6 | 
 7 | /**
 8 |  * This function takes a node of a DOM
 9 |  * document and makes it into a SimpleXML node. This new object can
10 |  * then be used as a native SimpleXML element.
11 |  *
12 |  * @param \DOMNode $node A DOM Element node
13 |  * @param string $class_name You may use this optional parameter so that
14 |  * simplexml_import_dom will return an object of
15 |  * the specified class. That class should extend the
16 |  * SimpleXMLElement class.
17 |  * @return \SimpleXMLElement Returns a SimpleXMLElement.
18 |  * @throws SimplexmlException
19 |  *
20 |  */
21 | function simplexml_import_dom(\DOMNode $node, string $class_name = "SimpleXMLElement"): \SimpleXMLElement
22 | {
23 |     error_clear_last();
24 |     $result = \simplexml_import_dom($node, $class_name);
25 |     if ($result === null) {
26 |         throw SimplexmlException::createFromPhpError();
27 |     }
28 |     return $result;
29 | }
30 | 
31 | 
32 | /**
33 |  * Convert the well-formed XML document in the given file to an object.
34 |  *
35 |  * @param string $filename Path to the XML file
36 |  *
37 |  * Libxml 2 unescapes the URI, so if you want to pass e.g.
38 |  * b&amp;c as the URI parameter a,
39 |  * you have to call
40 |  * simplexml_load_file(rawurlencode('http://example.com/?a=' .
41 |  * urlencode('b&amp;c'))). Since PHP 5.1.0 you don't need to do
42 |  * this because PHP will do it for you.
43 |  * @param string $class_name You may use this optional parameter so that
44 |  * simplexml_load_file will return an object of
45 |  * the specified class. That class should extend the
46 |  * SimpleXMLElement class.
47 |  * @param int $options Since PHP 5.1.0 and Libxml 2.6.0, you may also use the
48 |  * options parameter to specify additional Libxml parameters.
49 |  * @param string $ns Namespace prefix or URI.
50 |  * @param bool $is_prefix TRUE if ns is a prefix, FALSE if it's a URI;
51 |  * defaults to FALSE.
52 |  * @return \SimpleXMLElement Returns an object of class SimpleXMLElement with
53 |  * properties containing the data held within the XML document.
54 |  * @throws SimplexmlException
55 |  *
56 |  */
57 | function simplexml_load_file(string $filename, string $class_name = "SimpleXMLElement", int $options = 0, string $ns = "", bool $is_prefix = false): \SimpleXMLElement
58 | {
59 |     error_clear_last();
60 |     $result = \simplexml_load_file($filename, $class_name, $options, $ns, $is_prefix);
61 |     if ($result === false) {
62 |         throw SimplexmlException::createFromPhpError();
63 |     }
64 |     return $result;
65 | }
66 | 
67 | 
68 | /**
69 |  * Takes a well-formed XML string and returns it as an object.
70 |  *
71 |  * @param string $data A well-formed XML string
72 |  * @param string $class_name You may use this optional parameter so that
73 |  * simplexml_load_string will return an object of
74 |  * the specified class. That class should extend the
75 |  * SimpleXMLElement class.
76 |  * @param int $options Since PHP 5.1.0 and Libxml 2.6.0, you may also use the
77 |  * options parameter to specify additional Libxml parameters.
78 |  * @param string $ns Namespace prefix or URI.
79 |  * @param bool $is_prefix TRUE if ns is a prefix, FALSE if it's a URI;
80 |  * defaults to FALSE.
81 |  * @return \SimpleXMLElement Returns an object of class SimpleXMLElement with
82 |  * properties containing the data held within the xml document.
83 |  * @throws SimplexmlException
84 |  *
85 |  */
86 | function simplexml_load_string(string $data, string $class_name = "SimpleXMLElement", int $options = 0, string $ns = "", bool $is_prefix = false): \SimpleXMLElement
87 | {
88 |     error_clear_last();
89 |     $result = \simplexml_load_string($data, $class_name, $options, $ns, $is_prefix);
90 |     if ($result === false) {
91 |         throw SimplexmlException::createFromPhpError();
92 |     }
93 |     return $result;
94 | }
95 | 


--------------------------------------------------------------------------------
/generated/xml.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Safe;
  4 | 
  5 | use Safe\Exceptions\XmlException;
  6 | 
  7 | /**
  8 |  * xml_parser_create_ns creates a new XML parser
  9 |  * with XML namespace support and returns a XMLParser
 10 |  * instance to be used by the other XML functions.
 11 |  *
 12 |  * @param string $encoding The input encoding is automatically detected, so that the
 13 |  * encoding parameter specifies only the output
 14 |  * encoding. In PHP 5.0.0 and 5.0.1, the default output charset is
 15 |  * ISO-8859-1, while in PHP 5.0.2 and upper is UTF-8. The supported
 16 |  * encodings are ISO-8859-1, UTF-8 and
 17 |  * US-ASCII.
 18 |  * @param string $separator With a namespace aware parser tag parameters passed to the various
 19 |  * handler functions will consist of namespace and tag name separated by
 20 |  * the string specified in separator.
 21 |  * @return resource Returns a new XMLParser instance.
 22 |  * @throws XmlException
 23 |  *
 24 |  */
 25 | function xml_parser_create_ns(string $encoding = null, string $separator = ":")
 26 | {
 27 |     error_clear_last();
 28 |     if ($separator !== ":") {
 29 |         $result = \xml_parser_create_ns($encoding, $separator);
 30 |     } elseif ($encoding !== null) {
 31 |         $result = \xml_parser_create_ns($encoding);
 32 |     } else {
 33 |         $result = \xml_parser_create_ns();
 34 |     }
 35 |     if ($result === false) {
 36 |         throw XmlException::createFromPhpError();
 37 |     }
 38 |     return $result;
 39 | }
 40 | 
 41 | 
 42 | /**
 43 |  * xml_parser_create creates a new XML parser
 44 |  * and returns a XMLParser instance to be used by the
 45 |  * other XML functions.
 46 |  *
 47 |  * @param string $encoding The optional encoding specifies the character
 48 |  * encoding for the input/output in PHP 4. Starting from PHP 5, the input
 49 |  * encoding is automatically detected, so that the
 50 |  * encoding parameter specifies only the output
 51 |  * encoding. In PHP 4, the default output encoding is the same as the
 52 |  * input charset. If empty string is passed, the parser attempts to identify
 53 |  * which encoding the document is encoded in by looking at the heading 3 or
 54 |  * 4 bytes. In PHP 5.0.0 and 5.0.1, the default output charset is
 55 |  * ISO-8859-1, while in PHP 5.0.2 and upper is UTF-8. The supported
 56 |  * encodings are ISO-8859-1, UTF-8 and
 57 |  * US-ASCII.
 58 |  * @return resource Returns a new XMLParser instance.
 59 |  * @throws XmlException
 60 |  *
 61 |  */
 62 | function xml_parser_create(string $encoding = null)
 63 | {
 64 |     error_clear_last();
 65 |     if ($encoding !== null) {
 66 |         $result = \xml_parser_create($encoding);
 67 |     } else {
 68 |         $result = \xml_parser_create();
 69 |     }
 70 |     if ($result === false) {
 71 |         throw XmlException::createFromPhpError();
 72 |     }
 73 |     return $result;
 74 | }
 75 | 
 76 | 
 77 | /**
 78 |  * Frees the given XML parser.
 79 |  *
 80 |  * @param resource $parser
 81 |  * @throws XmlException
 82 |  *
 83 |  */
 84 | function xml_parser_free($parser): void
 85 | {
 86 |     error_clear_last();
 87 |     $result = \xml_parser_free($parser);
 88 |     if ($result === false) {
 89 |         throw XmlException::createFromPhpError();
 90 |     }
 91 | }
 92 | 
 93 | 
 94 | /**
 95 |  * This function allows to use parser inside
 96 |  * object. All callback functions could be set with
 97 |  * xml_set_element_handler etc and assumed to be
 98 |  * methods of object.
 99 |  *
100 |  * @param resource $parser A reference to the XML parser to use inside the object.
101 |  * @param object $object The object where to use the XML parser.
102 |  * @throws XmlException
103 |  *
104 |  */
105 | function xml_set_object($parser, object $object): void
106 | {
107 |     error_clear_last();
108 |     $result = \xml_set_object($parser, $object);
109 |     if ($result === false) {
110 |         throw XmlException::createFromPhpError();
111 |     }
112 | }
113 | 


--------------------------------------------------------------------------------
/generated/mysqlndMs.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Safe;
  4 | 
  5 | use Safe\Exceptions\MysqlndMsException;
  6 | 
  7 | /**
  8 |  * Returns a list of currently configured servers.
  9 |  *
 10 |  * @param mixed $connection A MySQL connection handle obtained from any of the
 11 |  * connect functions of the mysqli,
 12 |  * mysql or
 13 |  * PDO_MYSQL extensions.
 14 |  * @return array FALSE on error. Otherwise, returns an array with two entries
 15 |  * masters and slaves each of which contains
 16 |  * an array listing all corresponding servers.
 17 |  *
 18 |  * The function can be used to check and debug the list of servers currently
 19 |  * used by the plugin. It is mostly useful when the list of servers changes at
 20 |  * runtime, for example, when using MySQL Fabric.
 21 |  *
 22 |  * masters and slaves server entries
 23 |  * @throws MysqlndMsException
 24 |  *
 25 |  */
 26 | function mysqlnd_ms_dump_servers($connection): array
 27 | {
 28 |     error_clear_last();
 29 |     $result = \mysqlnd_ms_dump_servers($connection);
 30 |     if ($result === false) {
 31 |         throw MysqlndMsException::createFromPhpError();
 32 |     }
 33 |     return $result;
 34 | }
 35 | 
 36 | 
 37 | /**
 38 |  * MySQL Fabric related.
 39 |  *
 40 |  * Switch the connection to the nodes handling global sharding queries
 41 |  * for the given table name.
 42 |  *
 43 |  * @param mixed $connection A MySQL connection handle obtained from any of the
 44 |  * connect functions of the mysqli,
 45 |  * mysql or
 46 |  * PDO_MYSQL extensions.
 47 |  * @param mixed $table_name The table name to ask Fabric about.
 48 |  * @return array FALSE on error. Otherwise, TRUE
 49 |  * @throws MysqlndMsException
 50 |  *
 51 |  */
 52 | function mysqlnd_ms_fabric_select_global($connection, $table_name): array
 53 | {
 54 |     error_clear_last();
 55 |     $result = \mysqlnd_ms_fabric_select_global($connection, $table_name);
 56 |     if ($result === false) {
 57 |         throw MysqlndMsException::createFromPhpError();
 58 |     }
 59 |     return $result;
 60 | }
 61 | 
 62 | 
 63 | /**
 64 |  * MySQL Fabric related.
 65 |  *
 66 |  * Switch the connection to the shards responsible for the
 67 |  * given table name and shard key.
 68 |  *
 69 |  * @param mixed $connection A MySQL connection handle obtained from any of the
 70 |  * connect functions of the mysqli,
 71 |  * mysql or
 72 |  * PDO_MYSQL extensions.
 73 |  * @param mixed $table_name The table name to ask Fabric about.
 74 |  * @param mixed $shard_key The shard key to ask Fabric about.
 75 |  * @return array FALSE on error. Otherwise, TRUE
 76 |  * @throws MysqlndMsException
 77 |  *
 78 |  */
 79 | function mysqlnd_ms_fabric_select_shard($connection, $table_name, $shard_key): array
 80 | {
 81 |     error_clear_last();
 82 |     $result = \mysqlnd_ms_fabric_select_shard($connection, $table_name, $shard_key);
 83 |     if ($result === false) {
 84 |         throw MysqlndMsException::createFromPhpError();
 85 |     }
 86 |     return $result;
 87 | }
 88 | 
 89 | 
 90 | /**
 91 |  * Returns an array which describes the last used connection from the plugins
 92 |  * connection pool currently pointed to by the user connection handle. If using the
 93 |  * plugin, a user connection handle represents a pool of database connections.
 94 |  * It is not possible to tell from the user connection handles properties to which
 95 |  * database server from the pool the user connection handle points.
 96 |  *
 97 |  * The function can be used to debug or monitor PECL mysqlnd_ms.
 98 |  *
 99 |  * @param mixed $connection A MySQL connection handle obtained from any of the
100 |  * connect functions of the mysqli,
101 |  * mysql or
102 |  * PDO_MYSQL extensions.
103 |  * @return array FALSE on error. Otherwise, an
104 |  * array which describes the connection used to
105 |  * execute the last statement on.
106 |  *
107 |  * Array which describes the connection.
108 |  * @throws MysqlndMsException
109 |  *
110 |  */
111 | function mysqlnd_ms_get_last_used_connection($connection): array
112 | {
113 |     error_clear_last();
114 |     $result = \mysqlnd_ms_get_last_used_connection($connection);
115 |     if ($result === false) {
116 |         throw MysqlndMsException::createFromPhpError();
117 |     }
118 |     return $result;
119 | }
120 | 


--------------------------------------------------------------------------------
/generated/zip.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Safe;
  4 | 
  5 | use Safe\Exceptions\ZipException;
  6 | 
  7 | /**
  8 |  * Closes the specified directory entry.
  9 |  *
 10 |  * @param resource $zip_entry A directory entry previously opened zip_entry_open.
 11 |  * @throws ZipException
 12 |  *
 13 |  */
 14 | function zip_entry_close($zip_entry): void
 15 | {
 16 |     error_clear_last();
 17 |     $result = \zip_entry_close($zip_entry);
 18 |     if ($result === false) {
 19 |         throw ZipException::createFromPhpError();
 20 |     }
 21 | }
 22 | 
 23 | 
 24 | /**
 25 |  * Returns the compressed size of the specified directory entry.
 26 |  *
 27 |  * @param resource $zip_entry A directory entry returned by zip_read.
 28 |  * @return int The compressed size.
 29 |  * @throws ZipException
 30 |  *
 31 |  */
 32 | function zip_entry_compressedsize($zip_entry): int
 33 | {
 34 |     error_clear_last();
 35 |     $result = \zip_entry_compressedsize($zip_entry);
 36 |     if ($result === false) {
 37 |         throw ZipException::createFromPhpError();
 38 |     }
 39 |     return $result;
 40 | }
 41 | 
 42 | 
 43 | /**
 44 |  * Returns the compression method of the directory entry specified
 45 |  * by zip_entry.
 46 |  *
 47 |  * @param resource $zip_entry A directory entry returned by zip_read.
 48 |  * @return string The compression method.
 49 |  * @throws ZipException
 50 |  *
 51 |  */
 52 | function zip_entry_compressionmethod($zip_entry): string
 53 | {
 54 |     error_clear_last();
 55 |     $result = \zip_entry_compressionmethod($zip_entry);
 56 |     if ($result === false) {
 57 |         throw ZipException::createFromPhpError();
 58 |     }
 59 |     return $result;
 60 | }
 61 | 
 62 | 
 63 | /**
 64 |  * Returns the actual size of the specified directory entry.
 65 |  *
 66 |  * @param resource $zip_entry A directory entry returned by zip_read.
 67 |  * @return int The size of the directory entry.
 68 |  * @throws ZipException
 69 |  *
 70 |  */
 71 | function zip_entry_filesize($zip_entry): int
 72 | {
 73 |     error_clear_last();
 74 |     $result = \zip_entry_filesize($zip_entry);
 75 |     if ($result === false) {
 76 |         throw ZipException::createFromPhpError();
 77 |     }
 78 |     return $result;
 79 | }
 80 | 
 81 | 
 82 | /**
 83 |  * Returns the name of the specified directory entry.
 84 |  *
 85 |  * @param resource $zip_entry A directory entry returned by zip_read.
 86 |  * @return string The name of the directory entry.
 87 |  * @throws ZipException
 88 |  *
 89 |  */
 90 | function zip_entry_name($zip_entry): string
 91 | {
 92 |     error_clear_last();
 93 |     $result = \zip_entry_name($zip_entry);
 94 |     if ($result === false) {
 95 |         throw ZipException::createFromPhpError();
 96 |     }
 97 |     return $result;
 98 | }
 99 | 
100 | 
101 | /**
102 |  * Opens a directory entry in a zip file for reading.
103 |  *
104 |  * @param resource $zip_dp A valid resource handle returned by zip_open.
105 |  * @param resource $zip_entry A directory entry returned by zip_read.
106 |  * @param string $mode Any of the modes specified in the documentation of
107 |  * fopen.
108 |  *
109 |  * Currently, mode is ignored and is always
110 |  * "rb". This is due to the fact that zip support
111 |  * in PHP is read only access.
112 |  * @throws ZipException
113 |  *
114 |  */
115 | function zip_entry_open($zip_dp, $zip_entry, string $mode = "rb"): void
116 | {
117 |     error_clear_last();
118 |     $result = \zip_entry_open($zip_dp, $zip_entry, $mode);
119 |     if ($result === false) {
120 |         throw ZipException::createFromPhpError();
121 |     }
122 | }
123 | 
124 | 
125 | /**
126 |  * Reads from an open directory entry.
127 |  *
128 |  * @param resource $zip_entry A directory entry returned by zip_read.
129 |  * @param int $len The number of bytes to return.
130 |  *
131 |  * This should be the uncompressed length you wish to read.
132 |  * @return string Returns the data read, empty string on end of a file.
133 |  * @throws ZipException
134 |  *
135 |  */
136 | function zip_entry_read($zip_entry, int $len = 1024): string
137 | {
138 |     error_clear_last();
139 |     $result = \zip_entry_read($zip_entry, $len);
140 |     if ($result === false) {
141 |         throw ZipException::createFromPhpError();
142 |     }
143 |     return $result;
144 | }
145 | 


--------------------------------------------------------------------------------
/generated/yaml.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Safe;
  4 | 
  5 | use Safe\Exceptions\YamlException;
  6 | 
  7 | /**
  8 |  * Convert all or part of a YAML document stream read from a file to a PHP variable.
  9 |  *
 10 |  * @param string $filename Path to the file.
 11 |  * @param int $pos Document to extract from stream (-1 for all
 12 |  * documents, 0 for first document, ...).
 13 |  * @param int|null $ndocs If ndocs is provided, then it is filled with the
 14 |  * number of documents found in stream.
 15 |  * @param array $callbacks Content handlers for YAML nodes. Associative array of YAML
 16 |  * tag =&gt; callable mappings. See
 17 |  * parse callbacks for more
 18 |  * details.
 19 |  * @return mixed Returns the value encoded in input in appropriate
 20 |  * PHP type. If pos is -1 an
 21 |  * array will be returned with one entry for each document found
 22 |  * in the stream.
 23 |  * @throws YamlException
 24 |  *
 25 |  */
 26 | function yaml_parse_file(string $filename, int $pos = 0, ?int &$ndocs = null, array $callbacks = null)
 27 | {
 28 |     error_clear_last();
 29 |     if ($callbacks !== null) {
 30 |         $result = \yaml_parse_file($filename, $pos, $ndocs, $callbacks);
 31 |     } else {
 32 |         $result = \yaml_parse_file($filename, $pos, $ndocs);
 33 |     }
 34 |     if ($result === false) {
 35 |         throw YamlException::createFromPhpError();
 36 |     }
 37 |     return $result;
 38 | }
 39 | 
 40 | 
 41 | /**
 42 |  * Convert all or part of a YAML document stream read from a URL to a PHP variable.
 43 |  *
 44 |  * @param string $url url should be of the form "scheme://...". PHP
 45 |  * will search for a protocol handler (also known as a wrapper) for that
 46 |  * scheme. If no wrappers for that protocol are registered, PHP will emit
 47 |  * a notice to help you track potential problems in your script and then
 48 |  * continue as though filename specifies a regular file.
 49 |  * @param int $pos Document to extract from stream (-1 for all
 50 |  * documents, 0 for first document, ...).
 51 |  * @param int|null $ndocs If ndocs is provided, then it is filled with the
 52 |  * number of documents found in stream.
 53 |  * @param array $callbacks Content handlers for YAML nodes. Associative array of YAML
 54 |  * tag =&gt; callable mappings. See
 55 |  * parse callbacks for more
 56 |  * @return mixed Returns the value encoded in input in appropriate
 57 |  * PHP type. If pos is
 58 |  * -1 an array will be returned with one entry
 59 |  * for each document found in the stream.
 60 |  * @throws YamlException
 61 |  *
 62 |  */
 63 | function yaml_parse_url(string $url, int $pos = 0, ?int &$ndocs = null, array $callbacks = null)
 64 | {
 65 |     error_clear_last();
 66 |     if ($callbacks !== null) {
 67 |         $result = \yaml_parse_url($url, $pos, $ndocs, $callbacks);
 68 |     } else {
 69 |         $result = \yaml_parse_url($url, $pos, $ndocs);
 70 |     }
 71 |     if ($result === false) {
 72 |         throw YamlException::createFromPhpError();
 73 |     }
 74 |     return $result;
 75 | }
 76 | 
 77 | 
 78 | /**
 79 |  * Convert all or part of a YAML document stream to a PHP variable.
 80 |  *
 81 |  * @param string $input The string to parse as a YAML document stream.
 82 |  * @param int $pos Document to extract from stream (-1 for all
 83 |  * documents, 0 for first document, ...).
 84 |  * @param int|null $ndocs If ndocs is provided, then it is filled with the
 85 |  * number of documents found in stream.
 86 |  * @param array $callbacks Content handlers for YAML nodes. Associative array of YAML
 87 |  * tag =&gt; callable mappings. See
 88 |  * parse callbacks for more
 89 |  * details.
 90 |  * @return mixed Returns the value encoded in input in appropriate
 91 |  * PHP type. If pos is -1 an
 92 |  * array will be returned with one entry for each document found
 93 |  * in the stream.
 94 |  * @throws YamlException
 95 |  *
 96 |  */
 97 | function yaml_parse(string $input, int $pos = 0, ?int &$ndocs = null, array $callbacks = null)
 98 | {
 99 |     error_clear_last();
100 |     if ($callbacks !== null) {
101 |         $result = \yaml_parse($input, $pos, $ndocs, $callbacks);
102 |     } else {
103 |         $result = \yaml_parse($input, $pos, $ndocs);
104 |     }
105 |     if ($result === false) {
106 |         throw YamlException::createFromPhpError();
107 |     }
108 |     return $result;
109 | }
110 | 


--------------------------------------------------------------------------------
/generated/mailparse.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Safe;
  4 | 
  5 | use Safe\Exceptions\MailparseException;
  6 | 
  7 | /**
  8 |  * Extracts/decodes a message section from the supplied filename.
  9 |  *
 10 |  * The contents of the section will be decoded according to their transfer
 11 |  * encoding - base64, quoted-printable and uuencoded text are supported.
 12 |  *
 13 |  * @param resource $mimemail A valid MIME resource, created with
 14 |  * mailparse_msg_create.
 15 |  * @param mixed $filename Can be a file name or a valid stream resource.
 16 |  * @param callable $callbackfunc If set, this must be either a valid callback that will be passed the
 17 |  * extracted section, or NULL to make this function return the
 18 |  * extracted section.
 19 |  *
 20 |  * If not specified, the contents will be sent to "stdout".
 21 |  * @return string If callbackfunc is not NULL returns TRUE on
 22 |  * success.
 23 |  *
 24 |  * If callbackfunc is set to NULL, returns the
 25 |  * extracted section as a string.
 26 |  * @throws MailparseException
 27 |  *
 28 |  */
 29 | function mailparse_msg_extract_part_file($mimemail, $filename, callable $callbackfunc = null): string
 30 | {
 31 |     error_clear_last();
 32 |     if ($callbackfunc !== null) {
 33 |         $result = \mailparse_msg_extract_part_file($mimemail, $filename, $callbackfunc);
 34 |     } else {
 35 |         $result = \mailparse_msg_extract_part_file($mimemail, $filename);
 36 |     }
 37 |     if ($result === false) {
 38 |         throw MailparseException::createFromPhpError();
 39 |     }
 40 |     return $result;
 41 | }
 42 | 
 43 | 
 44 | /**
 45 |  * Frees a MIME resource.
 46 |  *
 47 |  * @param resource $mimemail A valid MIME resource allocated by
 48 |  * mailparse_msg_create or
 49 |  * mailparse_msg_parse_file.
 50 |  * @throws MailparseException
 51 |  *
 52 |  */
 53 | function mailparse_msg_free($mimemail): void
 54 | {
 55 |     error_clear_last();
 56 |     $result = \mailparse_msg_free($mimemail);
 57 |     if ($result === false) {
 58 |         throw MailparseException::createFromPhpError();
 59 |     }
 60 | }
 61 | 
 62 | 
 63 | /**
 64 |  * Parses a file.
 65 |  * This is the optimal way of parsing a mail file that you have on disk.
 66 |  *
 67 |  * @param string $filename Path to the file holding the message.
 68 |  * The file is opened and streamed through the parser.
 69 |  *
 70 |  * The message contained in filename is supposed to end with a newline
 71 |  * (CRLF); otherwise the last line of the message will not be parsed.
 72 |  * @return resource Returns a MIME resource representing the structure.
 73 |  * @throws MailparseException
 74 |  *
 75 |  */
 76 | function mailparse_msg_parse_file(string $filename)
 77 | {
 78 |     error_clear_last();
 79 |     $result = \mailparse_msg_parse_file($filename);
 80 |     if ($result === false) {
 81 |         throw MailparseException::createFromPhpError();
 82 |     }
 83 |     return $result;
 84 | }
 85 | 
 86 | 
 87 | /**
 88 |  * Incrementally parse data into the supplied mime mail resource.
 89 |  *
 90 |  * This function allow you to stream portions of a file at a time, rather
 91 |  * than read and parse the whole thing.
 92 |  *
 93 |  * @param resource $mimemail A valid MIME resource.
 94 |  * @param string $data The final chunk of data is supposed to end with a newline
 95 |  * (CRLF); otherwise the last line of the message will not be parsed.
 96 |  * @throws MailparseException
 97 |  *
 98 |  */
 99 | function mailparse_msg_parse($mimemail, string $data): void
100 | {
101 |     error_clear_last();
102 |     $result = \mailparse_msg_parse($mimemail, $data);
103 |     if ($result === false) {
104 |         throw MailparseException::createFromPhpError();
105 |     }
106 | }
107 | 
108 | 
109 | /**
110 |  * Streams data from the source file pointer, apply
111 |  * encoding and write to the destination file pointer.
112 |  *
113 |  * @param resource $sourcefp A valid file handle. The file is streamed through the parser.
114 |  * @param resource $destfp The destination file handle in which the encoded data will be written.
115 |  * @param string $encoding One of the character encodings supported by the
116 |  * mbstring module.
117 |  * @throws MailparseException
118 |  *
119 |  */
120 | function mailparse_stream_encode($sourcefp, $destfp, string $encoding): void
121 | {
122 |     error_clear_last();
123 |     $result = \mailparse_stream_encode($sourcefp, $destfp, $encoding);
124 |     if ($result === false) {
125 |         throw MailparseException::createFromPhpError();
126 |     }
127 | }
128 | 


--------------------------------------------------------------------------------
/generated/password.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Safe;
  4 | 
  5 | use Safe\Exceptions\PasswordException;
  6 | 
  7 | /**
  8 |  * password_hash creates a new password hash using a strong one-way hashing
  9 |  * algorithm. password_hash is compatible with crypt.
 10 |  * Therefore, password hashes created by crypt can be used with
 11 |  * password_hash.
 12 |  *
 13 |  *
 14 |  *
 15 |  *
 16 |  * PASSWORD_DEFAULT - Use the bcrypt algorithm (default as of PHP 5.5.0).
 17 |  * Note that this constant is designed to change over time as new and stronger algorithms are added
 18 |  * to PHP. For that reason, the length of the result from using this identifier can change over
 19 |  * time. Therefore, it is recommended to store the result in a database column that can expand
 20 |  * beyond 60 characters (255 characters would be a good choice).
 21 |  *
 22 |  *
 23 |  *
 24 |  *
 25 |  * PASSWORD_BCRYPT - Use the CRYPT_BLOWFISH algorithm to
 26 |  * create the hash. This will produce a standard crypt compatible hash using
 27 |  * the "$2y$" identifier. The result will always be a 60 character string.
 28 |  *
 29 |  *
 30 |  *
 31 |  *
 32 |  * PASSWORD_ARGON2I - Use the Argon2i hashing algorithm to create the hash.
 33 |  * This algorithm is only available if PHP has been compiled with Argon2 support.
 34 |  *
 35 |  *
 36 |  *
 37 |  *
 38 |  * PASSWORD_ARGON2ID - Use the Argon2id hashing algorithm to create the hash.
 39 |  * This algorithm is only available if PHP has been compiled with Argon2 support.
 40 |  *
 41 |  *
 42 |  *
 43 |  *
 44 |  *
 45 |  *
 46 |  *
 47 |  * salt (string) - to manually provide a salt to use when hashing the password.
 48 |  * Note that this will override and prevent a salt from being automatically generated.
 49 |  *
 50 |  *
 51 |  * If omitted, a random salt will be generated by password_hash for
 52 |  * each password hashed. This is the intended mode of operation.
 53 |  *
 54 |  *
 55 |  *
 56 |  * The salt option has been deprecated as of PHP 7.0.0. It is now
 57 |  * preferred to simply use the salt that is generated by default.
 58 |  *
 59 |  *
 60 |  *
 61 |  *
 62 |  *
 63 |  * cost (int) - which denotes the algorithmic cost that should be used.
 64 |  * Examples of these values can be found on the crypt page.
 65 |  *
 66 |  *
 67 |  * If omitted, a default value of 10 will be used. This is a good
 68 |  * baseline cost, but you may want to consider increasing it depending on your hardware.
 69 |  *
 70 |  *
 71 |  *
 72 |  *
 73 |  *
 74 |  *
 75 |  *
 76 |  * memory_cost (int) - Maximum memory (in kibibytes) that may
 77 |  * be used to compute the Argon2 hash. Defaults to PASSWORD_ARGON2_DEFAULT_MEMORY_COST.
 78 |  *
 79 |  *
 80 |  *
 81 |  *
 82 |  * time_cost (int) - Maximum amount of time it may
 83 |  * take to compute the Argon2 hash. Defaults to PASSWORD_ARGON2_DEFAULT_TIME_COST.
 84 |  *
 85 |  *
 86 |  *
 87 |  *
 88 |  * threads (int) - Number of threads to use for computing
 89 |  * the Argon2 hash. Defaults to PASSWORD_ARGON2_DEFAULT_THREADS.
 90 |  *
 91 |  *
 92 |  *
 93 |  *
 94 |  * @param string $password The user's password.
 95 |  *
 96 |  * Using the PASSWORD_BCRYPT as the
 97 |  * algorithm, will result
 98 |  * in the password parameter being truncated to a
 99 |  * maximum length of 72 characters.
100 |  * @param int|string|null $algo A password algorithm constant denoting the algorithm to use when hashing the password.
101 |  * @param array $options An associative array containing options. See the password algorithm constants for documentation on the supported options for each algorithm.
102 |  *
103 |  * If omitted, a random salt will be created and the default cost will be
104 |  * used.
105 |  * @return string Returns the hashed password.
106 |  *
107 |  * The used algorithm, cost and salt are returned as part of the hash. Therefore,
108 |  * all information that's needed to verify the hash is included in it. This allows
109 |  * the password_verify function to verify the hash without
110 |  * needing separate storage for the salt or algorithm information.
111 |  * @throws PasswordException
112 |  *
113 |  */
114 | function password_hash(string $password, $algo, array $options = null): string
115 | {
116 |     error_clear_last();
117 |     if ($options !== null) {
118 |         $result = \password_hash($password, $algo, $options);
119 |     } else {
120 |         $result = \password_hash($password, $algo);
121 |     }
122 |     if ($result === false) {
123 |         throw PasswordException::createFromPhpError();
124 |     }
125 |     return $result;
126 | }
127 | 


--------------------------------------------------------------------------------
/generated/outcontrol.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Safe;
  4 | 
  5 | use Safe\Exceptions\OutcontrolException;
  6 | 
  7 | /**
  8 |  * This function discards the contents of the output buffer.
  9 |  *
 10 |  * This function does not destroy the output buffer like
 11 |  * ob_end_clean does.
 12 |  *
 13 |  * The output buffer must be started by
 14 |  * ob_start with PHP_OUTPUT_HANDLER_CLEANABLE
 15 |  * flag. Otherwise ob_clean will not work.
 16 |  *
 17 |  * @throws OutcontrolException
 18 |  *
 19 |  */
 20 | function ob_clean(): void
 21 | {
 22 |     error_clear_last();
 23 |     $result = \ob_clean();
 24 |     if ($result === false) {
 25 |         throw OutcontrolException::createFromPhpError();
 26 |     }
 27 | }
 28 | 
 29 | 
 30 | /**
 31 |  * This function discards the contents of the topmost output buffer and turns
 32 |  * off this output buffering. If you want to further process the buffer's
 33 |  * contents you have to call ob_get_contents before
 34 |  * ob_end_clean as the buffer contents are discarded
 35 |  * when ob_end_clean is called.
 36 |  *
 37 |  * The output buffer must be started by
 38 |  * ob_start with PHP_OUTPUT_HANDLER_CLEANABLE
 39 |  * and PHP_OUTPUT_HANDLER_REMOVABLE
 40 |  * flags. Otherwise ob_end_clean will not work.
 41 |  *
 42 |  * @throws OutcontrolException
 43 |  *
 44 |  */
 45 | function ob_end_clean(): void
 46 | {
 47 |     error_clear_last();
 48 |     $result = \ob_end_clean();
 49 |     if ($result === false) {
 50 |         throw OutcontrolException::createFromPhpError();
 51 |     }
 52 | }
 53 | 
 54 | 
 55 | /**
 56 |  * This function will send the contents of the topmost output buffer (if
 57 |  * any) and turn this output buffer off.  If you want to further
 58 |  * process the buffer's contents you have to call
 59 |  * ob_get_contents before
 60 |  * ob_end_flush as the buffer contents are
 61 |  * discarded after ob_end_flush is called.
 62 |  *
 63 |  * The output buffer must be started by
 64 |  * ob_start with PHP_OUTPUT_HANDLER_FLUSHABLE
 65 |  * and PHP_OUTPUT_HANDLER_REMOVABLE
 66 |  * flags. Otherwise ob_end_flush will not work.
 67 |  *
 68 |  * @throws OutcontrolException
 69 |  *
 70 |  */
 71 | function ob_end_flush(): void
 72 | {
 73 |     error_clear_last();
 74 |     $result = \ob_end_flush();
 75 |     if ($result === false) {
 76 |         throw OutcontrolException::createFromPhpError();
 77 |     }
 78 | }
 79 | 
 80 | 
 81 | /**
 82 |  * This function will send the contents of the output buffer (if any). If you
 83 |  * want to further process the buffer's contents you have to call
 84 |  * ob_get_contents before ob_flush
 85 |  * as the buffer contents are discarded after ob_flush
 86 |  * is called.
 87 |  *
 88 |  * This function does not destroy the output buffer like
 89 |  * ob_end_flush does.
 90 |  *
 91 |  * @throws OutcontrolException
 92 |  *
 93 |  */
 94 | function ob_flush(): void
 95 | {
 96 |     error_clear_last();
 97 |     $result = \ob_flush();
 98 |     if ($result === false) {
 99 |         throw OutcontrolException::createFromPhpError();
100 |     }
101 | }
102 | 
103 | 
104 | /**
105 |  * This function adds another name/value pair to the URL rewrite mechanism.
106 |  * The name and value will be added to URLs (as GET parameter) and forms
107 |  * (as hidden input fields) the same way as the session ID when transparent
108 |  * URL rewriting is enabled with session.use_trans_sid.
109 |  *
110 |  * This function's behaviour is controlled by the url_rewriter.tags and
111 |  * url_rewriter.hosts php.ini
112 |  * parameters.
113 |  *
114 |  * Note that this function can be successfully called at most once per request.
115 |  *
116 |  * @param string $name The variable name.
117 |  * @param string $value The variable value.
118 |  * @throws OutcontrolException
119 |  *
120 |  */
121 | function output_add_rewrite_var(string $name, string $value): void
122 | {
123 |     error_clear_last();
124 |     $result = \output_add_rewrite_var($name, $value);
125 |     if ($result === false) {
126 |         throw OutcontrolException::createFromPhpError();
127 |     }
128 | }
129 | 
130 | 
131 | /**
132 |  * This function resets the URL rewriter and removes all rewrite
133 |  * variables previously set by the output_add_rewrite_var
134 |  * function.
135 |  *
136 |  * @throws OutcontrolException
137 |  *
138 |  */
139 | function output_reset_rewrite_vars(): void
140 | {
141 |     error_clear_last();
142 |     $result = \output_reset_rewrite_vars();
143 |     if ($result === false) {
144 |         throw OutcontrolException::createFromPhpError();
145 |     }
146 | }
147 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
  1 | {
  2 |     "name": "thecodingmachine/safe8",
  3 |     "description": "PHP8 core functions that throw exceptions instead of returning FALSE on error",
  4 |     "license": "MIT",
  5 |     "autoload": {
  6 |         "psr-4": {
  7 |             "Safe\\": [
  8 |                 "lib/",
  9 |                 "deprecated/",
 10 |                 "generated/"
 11 |             ]
 12 |         },
 13 |         "files": [
 14 |             "deprecated/apc.php",
 15 |             "deprecated/libevent.php",
 16 |             "deprecated/mssql.php",
 17 |             "deprecated/stats.php",
 18 |             "lib/special_cases.php",
 19 |             "generated/apache.php",
 20 |             "generated/apcu.php",
 21 |             "generated/array.php",
 22 |             "generated/bzip2.php",
 23 |             "generated/calendar.php",
 24 |             "generated/classobj.php",
 25 |             "generated/com.php",
 26 |             "generated/cubrid.php",
 27 |             "generated/curl.php",
 28 |             "generated/datetime.php",
 29 |             "generated/dir.php",
 30 |             "generated/eio.php",
 31 |             "generated/errorfunc.php",
 32 |             "generated/exec.php",
 33 |             "generated/fileinfo.php",
 34 |             "generated/filesystem.php",
 35 |             "generated/filter.php",
 36 |             "generated/fpm.php",
 37 |             "generated/ftp.php",
 38 |             "generated/funchand.php",
 39 |             "generated/gettext.php",
 40 |             "generated/gmp.php",
 41 |             "generated/gnupg.php",
 42 |             "generated/hash.php",
 43 |             "generated/ibase.php",
 44 |             "generated/ibmDb2.php",
 45 |             "generated/iconv.php",
 46 |             "generated/image.php",
 47 |             "generated/imap.php",
 48 |             "generated/info.php",
 49 |             "generated/ingres-ii.php",
 50 |             "generated/inotify.php",
 51 |             "generated/json.php",
 52 |             "generated/ldap.php",
 53 |             "generated/libxml.php",
 54 |             "generated/lzf.php",
 55 |             "generated/mailparse.php",
 56 |             "generated/mbstring.php",
 57 |             "generated/misc.php",
 58 |             "generated/mysql.php",
 59 |             "generated/mysqli.php",
 60 |             "generated/mysqlndMs.php",
 61 |             "generated/mysqlndQc.php",
 62 |             "generated/network.php",
 63 |             "generated/oci8.php",
 64 |             "generated/opcache.php",
 65 |             "generated/openssl.php",
 66 |             "generated/outcontrol.php",
 67 |             "generated/password.php",
 68 |             "generated/pcntl.php",
 69 |             "generated/pcre.php",
 70 |             "generated/pgsql.php",
 71 |             "generated/posix.php",
 72 |             "generated/ps.php",
 73 |             "generated/pspell.php",
 74 |             "generated/readline.php",
 75 |             "generated/rpminfo.php",
 76 |             "generated/rrd.php",
 77 |             "generated/sem.php",
 78 |             "generated/session.php",
 79 |             "generated/shmop.php",
 80 |             "generated/simplexml.php",
 81 |             "generated/sockets.php",
 82 |             "generated/solr.php",
 83 |             "generated/spl.php",
 84 |             "generated/sqlsrv.php",
 85 |             "generated/ssdeep.php",
 86 |             "generated/ssh2.php",
 87 |             "generated/stream.php",
 88 |             "generated/strings.php",
 89 |             "generated/swoole.php",
 90 |             "generated/uodbc.php",
 91 |             "generated/uopz.php",
 92 |             "generated/url.php",
 93 |             "generated/var.php",
 94 |             "generated/xdiff.php",
 95 |             "generated/xml.php",
 96 |             "generated/xmlrpc.php",
 97 |             "generated/yaml.php",
 98 |             "generated/yaz.php",
 99 |             "generated/zip.php",
100 |             "generated/zlib.php"
101 |         ]
102 |     },
103 |     "require": {
104 |         "php": ">=8.0"
105 |     },
106 |     "require-dev": {
107 |         "phpstan/phpstan": "^0.12",
108 |         "thecodingmachine/phpstan-strict-rules": "^0.12",
109 |         "squizlabs/php_codesniffer": "^3.2"
110 |     },
111 |     "scripts": {
112 |         "phpstan": "phpstan analyse lib -c phpstan.neon --level=max --no-progress -vvv",
113 |         "cs-fix": "phpcbf",
114 |         "cs-check": "phpcs"
115 |     },
116 |     "extra": {
117 |         "branch-alias": {
118 |             "dev-master": "0.1-dev"
119 |         }
120 |     }
121 | }


--------------------------------------------------------------------------------
/generated/readline.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Safe;
  4 | 
  5 | use Safe\Exceptions\ReadlineException;
  6 | 
  7 | /**
  8 |  * This function adds a line to the command line history.
  9 |  *
 10 |  * @param string $prompt The line to be added in the history.
 11 |  * @throws ReadlineException
 12 |  *
 13 |  */
 14 | function readline_add_history(string $prompt): void
 15 | {
 16 |     error_clear_last();
 17 |     $result = \readline_add_history($prompt);
 18 |     if ($result === false) {
 19 |         throw ReadlineException::createFromPhpError();
 20 |     }
 21 | }
 22 | 
 23 | 
 24 | /**
 25 |  * Sets up a readline callback interface then prints
 26 |  * prompt and immediately returns.
 27 |  * Calling this function twice without removing the previous
 28 |  * callback interface will automatically and conveniently overwrite the old
 29 |  * interface.
 30 |  *
 31 |  * The callback feature is useful when combined with
 32 |  * stream_select as it allows interleaving of IO and
 33 |  * user input, unlike readline.
 34 |  *
 35 |  *
 36 |  * Readline Callback Interface Example
 37 |  *
 38 |  * 10) {
 39 |  * $prompting = false;
 40 |  * readline_callback_handler_remove();
 41 |  * } else {
 42 |  * readline_callback_handler_install("[$c] Enter something: ", 'rl_callback');
 43 |  * }
 44 |  * }
 45 |  *
 46 |  * $c = 1;
 47 |  * $prompting = true;
 48 |  *
 49 |  * readline_callback_handler_install("[$c] Enter something: ", 'rl_callback');
 50 |  *
 51 |  * while ($prompting) {
 52 |  * $w = NULL;
 53 |  * $e = NULL;
 54 |  * $n = stream_select($r = array(STDIN), $w, $e, null);
 55 |  * if ($n && in_array(STDIN, $r)) {
 56 |  * // read a character, will call the callback when a newline is entered
 57 |  * readline_callback_read_char();
 58 |  * }
 59 |  * }
 60 |  *
 61 |  * echo "Prompting disabled. All done.\n";
 62 |  * ?>
 63 |  * ]]>
 64 |  *
 65 |  *
 66 |  *
 67 |  * @param string $prompt The prompt message.
 68 |  * @param callable $callback The callback function takes one parameter; the
 69 |  * user input returned.
 70 |  * @throws ReadlineException
 71 |  *
 72 |  */
 73 | function readline_callback_handler_install(string $prompt, callable $callback): void
 74 | {
 75 |     error_clear_last();
 76 |     $result = \readline_callback_handler_install($prompt, $callback);
 77 |     if ($result === false) {
 78 |         throw ReadlineException::createFromPhpError();
 79 |     }
 80 | }
 81 | 
 82 | 
 83 | /**
 84 |  * This function clears the entire command line history.
 85 |  *
 86 |  * @throws ReadlineException
 87 |  *
 88 |  */
 89 | function readline_clear_history(): void
 90 | {
 91 |     error_clear_last();
 92 |     $result = \readline_clear_history();
 93 |     if ($result === false) {
 94 |         throw ReadlineException::createFromPhpError();
 95 |     }
 96 | }
 97 | 
 98 | 
 99 | /**
100 |  * This function registers a completion function. This is the same kind of
101 |  * functionality you'd get if you hit your tab key while using Bash.
102 |  *
103 |  * @param callable $callback You must supply the name of an existing function which accepts a
104 |  * partial command line and returns an array of possible matches.
105 |  * @throws ReadlineException
106 |  *
107 |  */
108 | function readline_completion_function(callable $callback): void
109 | {
110 |     error_clear_last();
111 |     $result = \readline_completion_function($callback);
112 |     if ($result === false) {
113 |         throw ReadlineException::createFromPhpError();
114 |     }
115 | }
116 | 
117 | 
118 | /**
119 |  * This function reads a command history from a file.
120 |  *
121 |  * @param string $filename Path to the filename containing the command history.
122 |  * @throws ReadlineException
123 |  *
124 |  */
125 | function readline_read_history(string $filename = null): void
126 | {
127 |     error_clear_last();
128 |     if ($filename !== null) {
129 |         $result = \readline_read_history($filename);
130 |     } else {
131 |         $result = \readline_read_history();
132 |     }
133 |     if ($result === false) {
134 |         throw ReadlineException::createFromPhpError();
135 |     }
136 | }
137 | 
138 | 
139 | /**
140 |  * This function writes the command history to a file.
141 |  *
142 |  * @param string $filename Path to the saved file.
143 |  * @throws ReadlineException
144 |  *
145 |  */
146 | function readline_write_history(string $filename = null): void
147 | {
148 |     error_clear_last();
149 |     if ($filename !== null) {
150 |         $result = \readline_write_history($filename);
151 |     } else {
152 |         $result = \readline_write_history();
153 |     }
154 |     if ($result === false) {
155 |         throw ReadlineException::createFromPhpError();
156 |     }
157 | }
158 | 


--------------------------------------------------------------------------------
/generated/gnupg.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Safe;
  4 | 
  5 | use Safe\Exceptions\GnupgException;
  6 | 
  7 | /**
  8 |  *
  9 |  *
 10 |  * @param resource $identifier The gnupg identifier, from a call to
 11 |  * gnupg_init or gnupg.
 12 |  * @param string $fingerprint The fingerprint key.
 13 |  * @param string $passphrase The pass phrase.
 14 |  * @throws GnupgException
 15 |  *
 16 |  */
 17 | function gnupg_adddecryptkey($identifier, string $fingerprint, string $passphrase): void
 18 | {
 19 |     error_clear_last();
 20 |     $result = \gnupg_adddecryptkey($identifier, $fingerprint, $passphrase);
 21 |     if ($result === false) {
 22 |         throw GnupgException::createFromPhpError();
 23 |     }
 24 | }
 25 | 
 26 | 
 27 | /**
 28 |  *
 29 |  *
 30 |  * @param resource $identifier The gnupg identifier, from a call to
 31 |  * gnupg_init or gnupg.
 32 |  * @param string $fingerprint The fingerprint key.
 33 |  * @throws GnupgException
 34 |  *
 35 |  */
 36 | function gnupg_addencryptkey($identifier, string $fingerprint): void
 37 | {
 38 |     error_clear_last();
 39 |     $result = \gnupg_addencryptkey($identifier, $fingerprint);
 40 |     if ($result === false) {
 41 |         throw GnupgException::createFromPhpError();
 42 |     }
 43 | }
 44 | 
 45 | 
 46 | /**
 47 |  *
 48 |  *
 49 |  * @param resource $identifier The gnupg identifier, from a call to
 50 |  * gnupg_init or gnupg.
 51 |  * @param string $fingerprint The fingerprint key.
 52 |  * @param string $passphrase The pass phrase.
 53 |  * @throws GnupgException
 54 |  *
 55 |  */
 56 | function gnupg_addsignkey($identifier, string $fingerprint, string $passphrase = null): void
 57 | {
 58 |     error_clear_last();
 59 |     if ($passphrase !== null) {
 60 |         $result = \gnupg_addsignkey($identifier, $fingerprint, $passphrase);
 61 |     } else {
 62 |         $result = \gnupg_addsignkey($identifier, $fingerprint);
 63 |     }
 64 |     if ($result === false) {
 65 |         throw GnupgException::createFromPhpError();
 66 |     }
 67 | }
 68 | 
 69 | 
 70 | /**
 71 |  *
 72 |  *
 73 |  * @param resource $identifier The gnupg identifier, from a call to
 74 |  * gnupg_init or gnupg.
 75 |  * @throws GnupgException
 76 |  *
 77 |  */
 78 | function gnupg_cleardecryptkeys($identifier): void
 79 | {
 80 |     error_clear_last();
 81 |     $result = \gnupg_cleardecryptkeys($identifier);
 82 |     if ($result === false) {
 83 |         throw GnupgException::createFromPhpError();
 84 |     }
 85 | }
 86 | 
 87 | 
 88 | /**
 89 |  *
 90 |  *
 91 |  * @param resource $identifier The gnupg identifier, from a call to
 92 |  * gnupg_init or gnupg.
 93 |  * @throws GnupgException
 94 |  *
 95 |  */
 96 | function gnupg_clearencryptkeys($identifier): void
 97 | {
 98 |     error_clear_last();
 99 |     $result = \gnupg_clearencryptkeys($identifier);
100 |     if ($result === false) {
101 |         throw GnupgException::createFromPhpError();
102 |     }
103 | }
104 | 
105 | 
106 | /**
107 |  *
108 |  *
109 |  * @param resource $identifier The gnupg identifier, from a call to
110 |  * gnupg_init or gnupg.
111 |  * @throws GnupgException
112 |  *
113 |  */
114 | function gnupg_clearsignkeys($identifier): void
115 | {
116 |     error_clear_last();
117 |     $result = \gnupg_clearsignkeys($identifier);
118 |     if ($result === false) {
119 |         throw GnupgException::createFromPhpError();
120 |     }
121 | }
122 | 
123 | 
124 | /**
125 |  * Toggle the armored output.
126 |  *
127 |  * @param resource $identifier The gnupg identifier, from a call to
128 |  * gnupg_init or gnupg.
129 |  * @param int $armor Pass a non-zero integer-value to this function to enable armored-output
130 |  * (default).
131 |  * Pass 0 to disable armored output.
132 |  * @throws GnupgException
133 |  *
134 |  */
135 | function gnupg_setarmor($identifier, int $armor): void
136 | {
137 |     error_clear_last();
138 |     $result = \gnupg_setarmor($identifier, $armor);
139 |     if ($result === false) {
140 |         throw GnupgException::createFromPhpError();
141 |     }
142 | }
143 | 
144 | 
145 | /**
146 |  * Sets the mode for signing.
147 |  *
148 |  * @param resource $identifier The gnupg identifier, from a call to
149 |  * gnupg_init or gnupg.
150 |  * @param int $signmode The mode for signing.
151 |  *
152 |  * signmode takes a constant indicating what type of
153 |  * signature should be produced. The possible values are
154 |  * GNUPG_SIG_MODE_NORMAL,
155 |  * GNUPG_SIG_MODE_DETACH and
156 |  * GNUPG_SIG_MODE_CLEAR.
157 |  * By default GNUPG_SIG_MODE_CLEAR is used.
158 |  * @throws GnupgException
159 |  *
160 |  */
161 | function gnupg_setsignmode($identifier, int $signmode): void
162 | {
163 |     error_clear_last();
164 |     $result = \gnupg_setsignmode($identifier, $signmode);
165 |     if ($result === false) {
166 |         throw GnupgException::createFromPhpError();
167 |     }
168 | }
169 | 


--------------------------------------------------------------------------------
/generated/dir.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Safe;
  4 | 
  5 | use Safe\Exceptions\DirException;
  6 | 
  7 | /**
  8 |  * Changes PHP's current directory to
  9 |  * directory.
 10 |  *
 11 |  * @param string $directory The new current directory
 12 |  * @throws DirException
 13 |  *
 14 |  */
 15 | function chdir(string $directory): void
 16 | {
 17 |     error_clear_last();
 18 |     $result = \chdir($directory);
 19 |     if ($result === false) {
 20 |         throw DirException::createFromPhpError();
 21 |     }
 22 | }
 23 | 
 24 | 
 25 | /**
 26 |  * Changes the root directory of the current process to
 27 |  * directory, and changes the current
 28 |  * working directory to "/".
 29 |  *
 30 |  * This function is only available to GNU and BSD systems, and
 31 |  * only when using the CLI, CGI or Embed SAPI. Also, this function
 32 |  * requires root privileges.
 33 |  *
 34 |  * @param string $directory The path to change the root directory to.
 35 |  * @throws DirException
 36 |  *
 37 |  */
 38 | function chroot(string $directory): void
 39 | {
 40 |     error_clear_last();
 41 |     $result = \chroot($directory);
 42 |     if ($result === false) {
 43 |         throw DirException::createFromPhpError();
 44 |     }
 45 | }
 46 | 
 47 | 
 48 | /**
 49 |  * Gets the current working directory.
 50 |  *
 51 |  * @return string Returns the current working directory on success.
 52 |  *
 53 |  * On some Unix variants, getcwd will return
 54 |  * FALSE if any one of the parent directories does not have the
 55 |  * readable or search mode set, even if the current directory
 56 |  * does. See chmod for more information on
 57 |  * modes and permissions.
 58 |  * @throws DirException
 59 |  *
 60 |  */
 61 | function getcwd(): string
 62 | {
 63 |     error_clear_last();
 64 |     $result = \getcwd();
 65 |     if ($result === false) {
 66 |         throw DirException::createFromPhpError();
 67 |     }
 68 |     return $result;
 69 | }
 70 | 
 71 | 
 72 | /**
 73 |  * Opens up a directory handle to be used in subsequent
 74 |  * closedir, readdir, and
 75 |  * rewinddir calls.
 76 |  *
 77 |  * @param string $path The directory path that is to be opened
 78 |  * @param resource $context For a description of the context parameter,
 79 |  * refer to the streams section of
 80 |  * the manual.
 81 |  * @return resource Returns a directory handle resource on success
 82 |  * @throws DirException
 83 |  *
 84 |  */
 85 | function opendir(string $path, $context = null)
 86 | {
 87 |     error_clear_last();
 88 |     if ($context !== null) {
 89 |         $result = \opendir($path, $context);
 90 |     } else {
 91 |         $result = \opendir($path);
 92 |     }
 93 |     if ($result === false) {
 94 |         throw DirException::createFromPhpError();
 95 |     }
 96 |     return $result;
 97 | }
 98 | 
 99 | 
100 | /**
101 |  * Resets the directory stream indicated by
102 |  * dir_handle to the beginning of the
103 |  * directory.
104 |  *
105 |  * @param resource $dir_handle The directory handle resource previously opened
106 |  * with opendir. If the directory handle is
107 |  * not specified, the last link opened by opendir
108 |  * is assumed.
109 |  * @return null Returns NULL on success.
110 |  * @throws DirException
111 |  *
112 |  */
113 | function rewinddir($dir_handle = null)
114 | {
115 |     error_clear_last();
116 |     if ($dir_handle !== null) {
117 |         $result = \rewinddir($dir_handle);
118 |     } else {
119 |         $result = \rewinddir();
120 |     }
121 |     if ($result === false) {
122 |         throw DirException::createFromPhpError();
123 |     }
124 |     return $result;
125 | }
126 | 
127 | 
128 | /**
129 |  * Returns an array of files and directories from the
130 |  * directory.
131 |  *
132 |  * @param string $directory The directory that will be scanned.
133 |  * @param int $sorting_order By default, the sorted order is alphabetical in ascending order.  If
134 |  * the optional sorting_order is set to
135 |  * SCANDIR_SORT_DESCENDING, then the sort order is
136 |  * alphabetical in descending order. If it is set to
137 |  * SCANDIR_SORT_NONE then the result is unsorted.
138 |  * @param resource $context For a description of the context parameter,
139 |  * refer to the streams section of
140 |  * the manual.
141 |  * @return array Returns an array of filenames on success. If directory is not a directory, then
142 |  * boolean FALSE is returned, and an error of level
143 |  * E_WARNING is generated.
144 |  * @throws DirException
145 |  *
146 |  */
147 | function scandir(string $directory, int $sorting_order = SCANDIR_SORT_ASCENDING, $context = null): array
148 | {
149 |     error_clear_last();
150 |     if ($context !== null) {
151 |         $result = \scandir($directory, $sorting_order, $context);
152 |     } else {
153 |         $result = \scandir($directory, $sorting_order);
154 |     }
155 |     if ($result === false) {
156 |         throw DirException::createFromPhpError();
157 |     }
158 |     return $result;
159 | }
160 | 


--------------------------------------------------------------------------------
/generated/spl.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Safe;
  4 | 
  5 | use Safe\Exceptions\SplException;
  6 | 
  7 | /**
  8 |  * This function returns an array with the names of the interfaces that the
  9 |  * given class and its parents implement.
 10 |  *
 11 |  * @param object|string $class An object (class instance) or a string (class or interface name).
 12 |  * @param bool $autoload Whether to allow this function to load the class automatically through
 13 |  * the __autoload magic method.
 14 |  * @return array An array on success.
 15 |  * @throws SplException
 16 |  *
 17 |  */
 18 | function class_implements($class, bool $autoload = true): array
 19 | {
 20 |     error_clear_last();
 21 |     $result = \class_implements($class, $autoload);
 22 |     if ($result === false) {
 23 |         throw SplException::createFromPhpError();
 24 |     }
 25 |     return $result;
 26 | }
 27 | 
 28 | 
 29 | /**
 30 |  * This function returns an array with the name of the parent classes of
 31 |  * the given class.
 32 |  *
 33 |  * @param object|string $class An object (class instance) or a string (class name).
 34 |  * @param bool $autoload Whether to allow this function to load the class automatically through
 35 |  * the __autoload magic method.
 36 |  * @return array An array on success.
 37 |  * @throws SplException
 38 |  *
 39 |  */
 40 | function class_parents($class, bool $autoload = true): array
 41 | {
 42 |     error_clear_last();
 43 |     $result = \class_parents($class, $autoload);
 44 |     if ($result === false) {
 45 |         throw SplException::createFromPhpError();
 46 |     }
 47 |     return $result;
 48 | }
 49 | 
 50 | 
 51 | /**
 52 |  * This function returns an array with the names of the traits that the
 53 |  * given class uses. This does however not include
 54 |  * any traits used by a parent class.
 55 |  *
 56 |  * @param object|string $class An object (class instance) or a string (class name).
 57 |  * @param bool $autoload Whether to allow this function to load the class automatically through
 58 |  * the __autoload magic method.
 59 |  * @return array An array on success.
 60 |  * @throws SplException
 61 |  *
 62 |  */
 63 | function class_uses($class, bool $autoload = true): array
 64 | {
 65 |     error_clear_last();
 66 |     $result = \class_uses($class, $autoload);
 67 |     if ($result === false) {
 68 |         throw SplException::createFromPhpError();
 69 |     }
 70 |     return $result;
 71 | }
 72 | 
 73 | 
 74 | /**
 75 |  * Register a function with the spl provided __autoload queue. If the queue
 76 |  * is not yet activated it will be activated.
 77 |  *
 78 |  * If your code has an existing __autoload function then
 79 |  * this function must be explicitly registered on the __autoload queue. This
 80 |  * is because spl_autoload_register will effectively
 81 |  * replace the engine cache for the __autoload function
 82 |  * by either spl_autoload or
 83 |  * spl_autoload_call.
 84 |  *
 85 |  * If there must be multiple autoload functions, spl_autoload_register
 86 |  * allows for this. It effectively creates a queue of autoload functions, and
 87 |  * runs through each of them in the order they are defined. By contrast,
 88 |  * __autoload may only be defined once.
 89 |  *
 90 |  * @param callable(string):void $autoload_function The autoload function being registered.
 91 |  * If no parameter is provided, then the default implementation of
 92 |  * spl_autoload will be registered.
 93 |  * @param bool $throw This parameter specifies whether
 94 |  * spl_autoload_register should throw
 95 |  * exceptions when the autoload_function
 96 |  * cannot be registered.
 97 |  * @param bool $prepend If true, spl_autoload_register will prepend
 98 |  * the autoloader on the autoload queue instead of appending it.
 99 |  * @throws SplException
100 |  *
101 |  */
102 | function spl_autoload_register(callable $autoload_function = null, bool $throw = true, bool $prepend = false): void
103 | {
104 |     error_clear_last();
105 |     if ($prepend !== false) {
106 |         $result = \spl_autoload_register($autoload_function, $throw, $prepend);
107 |     } elseif ($throw !== true) {
108 |         $result = \spl_autoload_register($autoload_function, $throw);
109 |     } elseif ($autoload_function !== null) {
110 |         $result = \spl_autoload_register($autoload_function);
111 |     } else {
112 |         $result = \spl_autoload_register();
113 |     }
114 |     if ($result === false) {
115 |         throw SplException::createFromPhpError();
116 |     }
117 | }
118 | 
119 | 
120 | /**
121 |  * Removes a function from the autoload queue. If the queue
122 |  * is activated and empty after removing the given function then it will
123 |  * be deactivated.
124 |  *
125 |  * When this function results in the queue being deactivated, any
126 |  * __autoload function that previously existed will not be reactivated.
127 |  *
128 |  * @param mixed $autoload_function The autoload function being unregistered.
129 |  * @throws SplException
130 |  *
131 |  */
132 | function spl_autoload_unregister($autoload_function): void
133 | {
134 |     error_clear_last();
135 |     $result = \spl_autoload_unregister($autoload_function);
136 |     if ($result === false) {
137 |         throw SplException::createFromPhpError();
138 |     }
139 | }
140 | 


--------------------------------------------------------------------------------
/generated/pcntl.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Safe;
  4 | 
  5 | use Safe\Exceptions\PcntlException;
  6 | 
  7 | /**
  8 |  * Executes the program with the given arguments.
  9 |  *
 10 |  * @param string $path path must be the path to a binary executable or a
 11 |  * script with a valid path pointing to an executable in the shebang (
 12 |  * #!/usr/local/bin/perl for example) as the first line.  See your system's
 13 |  * man execve(2) page for additional information.
 14 |  * @param array $args args is an array of argument strings passed to the
 15 |  * program.
 16 |  * @param array $envs envs is an array of strings which are passed as
 17 |  * environment to the program.  The array is in the format of name =&gt; value,
 18 |  * the key being the name of the environmental variable and the value being
 19 |  * the value of that variable.
 20 |  * @throws PcntlException
 21 |  *
 22 |  */
 23 | function pcntl_exec(string $path, array $args = null, array $envs = null): void
 24 | {
 25 |     error_clear_last();
 26 |     if ($envs !== null) {
 27 |         $result = \pcntl_exec($path, $args, $envs);
 28 |     } elseif ($args !== null) {
 29 |         $result = \pcntl_exec($path, $args);
 30 |     } else {
 31 |         $result = \pcntl_exec($path);
 32 |     }
 33 |     if ($result === false) {
 34 |         throw PcntlException::createFromPhpError();
 35 |     }
 36 | }
 37 | 
 38 | 
 39 | /**
 40 |  * pcntl_getpriority gets the priority of
 41 |  * pid. Because priority levels can differ between
 42 |  * system types and kernel versions, please see your system's getpriority(2)
 43 |  * man page for specific details.
 44 |  *
 45 |  * @param int $pid If not specified, the pid of the current process is used.
 46 |  * @param int $process_identifier One of PRIO_PGRP, PRIO_USER
 47 |  * or PRIO_PROCESS.
 48 |  * @return int pcntl_getpriority returns the priority of the process.  A lower numerical value causes more favorable
 49 |  * scheduling.
 50 |  * @throws PcntlException
 51 |  *
 52 |  */
 53 | function pcntl_getpriority(int $pid = null, int $process_identifier = PRIO_PROCESS): int
 54 | {
 55 |     error_clear_last();
 56 |     if ($process_identifier !== PRIO_PROCESS) {
 57 |         $result = \pcntl_getpriority($pid, $process_identifier);
 58 |     } elseif ($pid !== null) {
 59 |         $result = \pcntl_getpriority($pid);
 60 |     } else {
 61 |         $result = \pcntl_getpriority();
 62 |     }
 63 |     if ($result === false) {
 64 |         throw PcntlException::createFromPhpError();
 65 |     }
 66 |     return $result;
 67 | }
 68 | 
 69 | 
 70 | /**
 71 |  * pcntl_setpriority sets the priority of
 72 |  * pid.
 73 |  *
 74 |  * @param int $priority priority is generally a value in the range
 75 |  * -20 to 20. The default priority
 76 |  * is 0 while a lower numerical value causes more
 77 |  * favorable scheduling.  Because priority levels can differ between
 78 |  * system types and kernel versions, please see your system's setpriority(2)
 79 |  * man page for specific details.
 80 |  * @param int $pid If not specified, the pid of the current process is used.
 81 |  * @param int $process_identifier One of PRIO_PGRP, PRIO_USER
 82 |  * or PRIO_PROCESS.
 83 |  * @throws PcntlException
 84 |  *
 85 |  */
 86 | function pcntl_setpriority(int $priority, int $pid = null, int $process_identifier = PRIO_PROCESS): void
 87 | {
 88 |     error_clear_last();
 89 |     if ($process_identifier !== PRIO_PROCESS) {
 90 |         $result = \pcntl_setpriority($priority, $pid, $process_identifier);
 91 |     } elseif ($pid !== null) {
 92 |         $result = \pcntl_setpriority($priority, $pid);
 93 |     } else {
 94 |         $result = \pcntl_setpriority($priority);
 95 |     }
 96 |     if ($result === false) {
 97 |         throw PcntlException::createFromPhpError();
 98 |     }
 99 | }
100 | 
101 | 
102 | /**
103 |  * The pcntl_signal_dispatch function calls the signal
104 |  * handlers installed by pcntl_signal for each pending
105 |  * signal.
106 |  *
107 |  * @throws PcntlException
108 |  *
109 |  */
110 | function pcntl_signal_dispatch(): void
111 | {
112 |     error_clear_last();
113 |     $result = \pcntl_signal_dispatch();
114 |     if ($result === false) {
115 |         throw PcntlException::createFromPhpError();
116 |     }
117 | }
118 | 
119 | 
120 | /**
121 |  * The pcntl_sigprocmask function adds, removes or sets blocked
122 |  * signals, depending on the how parameter.
123 |  *
124 |  * @param int $how Sets the behavior of pcntl_sigprocmask. Possible
125 |  * values:
126 |  *
127 |  * SIG_BLOCK: Add the signals to the
128 |  * currently blocked signals.
129 |  * SIG_UNBLOCK: Remove the signals from the
130 |  * currently blocked signals.
131 |  * SIG_SETMASK: Replace the currently
132 |  * blocked signals by the given list of signals.
133 |  *
134 |  * @param array $set List of signals.
135 |  * @param array|null $oldset The oldset parameter is set to an array
136 |  * containing the list of the previously blocked signals.
137 |  * @throws PcntlException
138 |  *
139 |  */
140 | function pcntl_sigprocmask(int $how, array $set, ?array &$oldset = null): void
141 | {
142 |     error_clear_last();
143 |     $result = \pcntl_sigprocmask($how, $set, $oldset);
144 |     if ($result === false) {
145 |         throw PcntlException::createFromPhpError();
146 |     }
147 | }
148 | 
149 | 
150 | /**
151 |  *
152 |  *
153 |  * @param int $errno
154 |  * @return string Returns error description on success.
155 |  * @throws PcntlException
156 |  *
157 |  */
158 | function pcntl_strerror(int $errno): string
159 | {
160 |     error_clear_last();
161 |     $result = \pcntl_strerror($errno);
162 |     if ($result === false) {
163 |         throw PcntlException::createFromPhpError();
164 |     }
165 |     return $result;
166 | }
167 | 


--------------------------------------------------------------------------------
/generated/url.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Safe;
  4 | 
  5 | use Safe\Exceptions\UrlException;
  6 | 
  7 | /**
  8 |  * Decodes a base64 encoded string.
  9 |  *
 10 |  * @param string $string The encoded data.
 11 |  * @param bool $strict If the strict parameter is set to TRUE
 12 |  * then the base64_decode function will return
 13 |  * FALSE if the input contains character from outside the base64
 14 |  * alphabet. Otherwise invalid characters will be silently discarded.
 15 |  * @return string Returns the decoded data. The returned data may be
 16 |  * binary.
 17 |  * @throws UrlException
 18 |  *
 19 |  */
 20 | function base64_decode(string $string, bool $strict = false): string
 21 | {
 22 |     error_clear_last();
 23 |     $result = \base64_decode($string, $strict);
 24 |     if ($result === false) {
 25 |         throw UrlException::createFromPhpError();
 26 |     }
 27 |     return $result;
 28 | }
 29 | 
 30 | 
 31 | /**
 32 |  * get_headers returns an array with the headers sent
 33 |  * by the server in response to a HTTP request.
 34 |  *
 35 |  * @param string $url The target URL.
 36 |  * @param int $format If the optional format parameter is set to non-zero,
 37 |  * get_headers parses the response and sets the
 38 |  * array's keys.
 39 |  * @param resource $context A valid context resource created with
 40 |  * stream_context_create.
 41 |  * @return array Returns an indexed or associative array with the headers.
 42 |  * @throws UrlException
 43 |  *
 44 |  */
 45 | function get_headers(string $url, int $format = 0, $context = null): array
 46 | {
 47 |     error_clear_last();
 48 |     if ($context !== null) {
 49 |         $result = \get_headers($url, $format, $context);
 50 |     } else {
 51 |         $result = \get_headers($url, $format);
 52 |     }
 53 |     if ($result === false) {
 54 |         throw UrlException::createFromPhpError();
 55 |     }
 56 |     return $result;
 57 | }
 58 | 
 59 | 
 60 | /**
 61 |  * Opens filename and parses it line by line for
 62 |  * &lt;meta&gt; tags in the file. The parsing stops at
 63 |  * &lt;/head&gt;.
 64 |  *
 65 |  * @param string $filename The path to the HTML file, as a string. This can be a local file or an
 66 |  * URL.
 67 |  *
 68 |  *
 69 |  * What get_meta_tags parses
 70 |  *
 71 |  *
 72 |  *
 73 |  *
 74 |  *
 75 |  *
 76 |  * ]]>
 77 |  *
 78 |  *
 79 |  * (pay attention to line endings - PHP uses a native function to
 80 |  * parse the input, so a Mac file won't work on Unix).
 81 |  * @param bool $use_include_path Setting use_include_path to TRUE will result
 82 |  * in PHP trying to open the file along the standard include path as per
 83 |  * the include_path directive.
 84 |  * This is used for local files, not URLs.
 85 |  * @return array Returns an array with all the parsed meta tags.
 86 |  *
 87 |  * The value of the name property becomes the key, the value of the content
 88 |  * property becomes the value of the returned array, so you can easily use
 89 |  * standard array functions to traverse it or access single values.
 90 |  * Special characters in the value of the name property are substituted with
 91 |  * '_', the rest is converted to lower case.  If two meta tags have the same
 92 |  * name, only the last one is returned.
 93 |  *
 94 |  * Returns FALSE on failure.
 95 |  * @throws UrlException
 96 |  *
 97 |  */
 98 | function get_meta_tags(string $filename, bool $use_include_path = false): array
 99 | {
100 |     error_clear_last();
101 |     $result = \get_meta_tags($filename, $use_include_path);
102 |     if ($result === false) {
103 |         throw UrlException::createFromPhpError();
104 |     }
105 |     return $result;
106 | }
107 | 
108 | 
109 | /**
110 |  * This function parses a URL and returns an associative array containing any
111 |  * of the various components of the URL that are present.
112 |  * The values of the array elements are not URL decoded.
113 |  *
114 |  * This function is not meant to validate
115 |  * the given URL, it only breaks it up into the above listed parts. Partial
116 |  * URLs are also accepted, parse_url tries its best to
117 |  * parse them correctly.
118 |  *
119 |  * @param string $url The URL to parse. Invalid characters are replaced by
120 |  * _.
121 |  * @param int $component Specify one of PHP_URL_SCHEME,
122 |  * PHP_URL_HOST, PHP_URL_PORT,
123 |  * PHP_URL_USER, PHP_URL_PASS,
124 |  * PHP_URL_PATH, PHP_URL_QUERY
125 |  * or PHP_URL_FRAGMENT to retrieve just a specific
126 |  * URL component as a string (except when
127 |  * PHP_URL_PORT is given, in which case the return
128 |  * value will be an int).
129 |  * @return mixed On seriously malformed URLs, parse_url.
130 |  *
131 |  * If the component parameter is omitted, an
132 |  * associative array is returned. At least one element will be
133 |  * present within the array. Potential keys within this array are:
134 |  *
135 |  *
136 |  *
137 |  * scheme - e.g. http
138 |  *
139 |  *
140 |  *
141 |  *
142 |  * host
143 |  *
144 |  *
145 |  *
146 |  *
147 |  * port
148 |  *
149 |  *
150 |  *
151 |  *
152 |  * user
153 |  *
154 |  *
155 |  *
156 |  *
157 |  * pass
158 |  *
159 |  *
160 |  *
161 |  *
162 |  * path
163 |  *
164 |  *
165 |  *
166 |  *
167 |  * query - after the question mark ?
168 |  *
169 |  *
170 |  *
171 |  *
172 |  * fragment - after the hashmark #
173 |  *
174 |  *
175 |  *
176 |  *
177 |  * If the component parameter is specified,
178 |  * parse_url returns a string (or an
179 |  * int, in the case of PHP_URL_PORT)
180 |  * instead of an array. If the requested component doesn't exist
181 |  * within the given URL, NULL will be returned.
182 |  * @throws UrlException
183 |  *
184 |  */
185 | function parse_url(string $url, int $component = -1)
186 | {
187 |     error_clear_last();
188 |     $result = \parse_url($url, $component);
189 |     if ($result === false) {
190 |         throw UrlException::createFromPhpError();
191 |     }
192 |     return $result;
193 | }
194 | 


--------------------------------------------------------------------------------
/generated/apache.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Safe;
  4 | 
  5 | use Safe\Exceptions\ApacheException;
  6 | 
  7 | /**
  8 |  * Fetch the Apache version.
  9 |  *
 10 |  * @return string Returns the Apache version on success.
 11 |  * @throws ApacheException
 12 |  *
 13 |  */
 14 | function apache_get_version(): string
 15 | {
 16 |     error_clear_last();
 17 |     $result = \apache_get_version();
 18 |     if ($result === false) {
 19 |         throw ApacheException::createFromPhpError();
 20 |     }
 21 |     return $result;
 22 | }
 23 | 
 24 | 
 25 | /**
 26 |  * Retrieve an Apache environment variable specified by
 27 |  * variable.
 28 |  *
 29 |  * @param string $variable The Apache environment variable
 30 |  * @param bool $walk_to_top Whether to get the top-level variable available to all Apache layers.
 31 |  * @return string The value of the Apache environment variable on success
 32 |  * @throws ApacheException
 33 |  *
 34 |  */
 35 | function apache_getenv(string $variable, bool $walk_to_top = false): string
 36 | {
 37 |     error_clear_last();
 38 |     $result = \apache_getenv($variable, $walk_to_top);
 39 |     if ($result === false) {
 40 |         throw ApacheException::createFromPhpError();
 41 |     }
 42 |     return $result;
 43 | }
 44 | 
 45 | 
 46 | /**
 47 |  * This performs a partial request for a URI.  It goes just far
 48 |  * enough to obtain all the important information about the given
 49 |  * resource.
 50 |  *
 51 |  * @param string $filename The filename (URI) that's being requested.
 52 |  * @return object An object of related URI information. The properties of
 53 |  * this object are:
 54 |  *
 55 |  *
 56 |  * status
 57 |  * the_request
 58 |  * status_line
 59 |  * method
 60 |  * content_type
 61 |  * handler
 62 |  * uri
 63 |  * filename
 64 |  * path_info
 65 |  * args
 66 |  * boundary
 67 |  * no_cache
 68 |  * no_local_copy
 69 |  * allowed
 70 |  * send_bodyct
 71 |  * bytes_sent
 72 |  * byterange
 73 |  * clength
 74 |  * unparsed_uri
 75 |  * mtime
 76 |  * request_time
 77 |  *
 78 |  *
 79 |  * Returns FALSE on failure.
 80 |  * @throws ApacheException
 81 |  *
 82 |  */
 83 | function apache_lookup_uri(string $filename): object
 84 | {
 85 |     error_clear_last();
 86 |     $result = \apache_lookup_uri($filename);
 87 |     if ($result === false) {
 88 |         throw ApacheException::createFromPhpError();
 89 |     }
 90 |     return $result;
 91 | }
 92 | 
 93 | 
 94 | /**
 95 |  * Fetches all HTTP request headers from the current request. Works in the
 96 |  * Apache, FastCGI, CLI, and FPM webservers.
 97 |  *
 98 |  * @return array An associative array of all the HTTP headers in the current request.
 99 |  * @throws ApacheException
100 |  *
101 |  */
102 | function apache_request_headers(): array
103 | {
104 |     error_clear_last();
105 |     $result = \apache_request_headers();
106 |     if ($result === false) {
107 |         throw ApacheException::createFromPhpError();
108 |     }
109 |     return $result;
110 | }
111 | 
112 | 
113 | /**
114 |  * Fetch all HTTP response headers.  Works in the
115 |  * Apache, FastCGI, CLI, and FPM webservers.
116 |  *
117 |  * @return array An array of all Apache response headers on success.
118 |  * @throws ApacheException
119 |  *
120 |  */
121 | function apache_response_headers(): array
122 | {
123 |     error_clear_last();
124 |     $result = \apache_response_headers();
125 |     if ($result === false) {
126 |         throw ApacheException::createFromPhpError();
127 |     }
128 |     return $result;
129 | }
130 | 
131 | 
132 | /**
133 |  * apache_setenv sets the value of the Apache
134 |  * environment variable specified by
135 |  * variable.
136 |  *
137 |  * @param string $variable The environment variable that's being set.
138 |  * @param string $value The new variable value.
139 |  * @param bool $walk_to_top Whether to set the top-level variable available to all Apache layers.
140 |  * @throws ApacheException
141 |  *
142 |  */
143 | function apache_setenv(string $variable, string $value, bool $walk_to_top = false): void
144 | {
145 |     error_clear_last();
146 |     $result = \apache_setenv($variable, $value, $walk_to_top);
147 |     if ($result === false) {
148 |         throw ApacheException::createFromPhpError();
149 |     }
150 | }
151 | 
152 | 
153 | /**
154 |  * Fetches all HTTP headers from the current request.
155 |  *
156 |  * This function is an alias for apache_request_headers.
157 |  * Please read the apache_request_headers
158 |  * documentation for more information on how this function works.
159 |  *
160 |  * @return array An associative array of all the HTTP headers in the current request.
161 |  * @throws ApacheException
162 |  *
163 |  */
164 | function getallheaders(): array
165 | {
166 |     error_clear_last();
167 |     $result = \getallheaders();
168 |     if ($result === false) {
169 |         throw ApacheException::createFromPhpError();
170 |     }
171 |     return $result;
172 | }
173 | 
174 | 
175 | /**
176 |  * virtual is an Apache-specific function which
177 |  * is similar to &lt;!--#include virtual...--&gt; in
178 |  * mod_include.
179 |  * It performs an Apache sub-request.  It is useful for including
180 |  * CGI scripts or .shtml files, or anything else that you would
181 |  * parse through Apache. Note that for a CGI script, the script
182 |  * must generate valid CGI headers.  At the minimum that means it
183 |  * must generate a Content-Type header.
184 |  *
185 |  * To run the sub-request, all buffers are terminated and flushed to the
186 |  * browser, pending headers are sent too.
187 |  *
188 |  * @param string $uri The file that the virtual command will be performed on.
189 |  * @throws ApacheException
190 |  *
191 |  */
192 | function virtual(string $uri): void
193 | {
194 |     error_clear_last();
195 |     $result = \virtual($uri);
196 |     if ($result === false) {
197 |         throw ApacheException::createFromPhpError();
198 |     }
199 | }
200 | 


--------------------------------------------------------------------------------
/generated/exec.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Safe;
  4 | 
  5 | use Safe\Exceptions\ExecException;
  6 | 
  7 | /**
  8 |  * exec executes the given
  9 |  * command.
 10 |  *
 11 |  * @param string $command The command that will be executed.
 12 |  * @param array|null $output If the output argument is present, then the
 13 |  * specified array will be filled with every line of output from the
 14 |  * command.  Trailing whitespace, such as \n, is not
 15 |  * included in this array.  Note that if the array already contains some
 16 |  * elements, exec will append to the end of the array.
 17 |  * If you do not want the function to append elements, call
 18 |  * unset on the array before passing it to
 19 |  * exec.
 20 |  * @param int|null $result_code If the result_code argument is present
 21 |  * along with the output argument, then the
 22 |  * return status of the executed command will be written to this
 23 |  * variable.
 24 |  * @return string The last line from the result of the command.  If you need to execute a
 25 |  * command and have all the data from the command passed directly back without
 26 |  * any interference, use the passthru function.
 27 |  *
 28 |  * Returns FALSE on failure.
 29 |  *
 30 |  * To get the output of the executed command, be sure to set and use the
 31 |  * output parameter.
 32 |  * @throws ExecException
 33 |  *
 34 |  */
 35 | function exec(string $command, ?array &$output = null, ?int &$result_code = null): string
 36 | {
 37 |     error_clear_last();
 38 |     $result = \exec($command, $output, $result_code);
 39 |     if ($result === false) {
 40 |         throw ExecException::createFromPhpError();
 41 |     }
 42 |     return $result;
 43 | }
 44 | 
 45 | 
 46 | /**
 47 |  * proc_get_status fetches data about a
 48 |  * process opened using proc_open.
 49 |  *
 50 |  * @param resource $process The proc_open resource that will
 51 |  * be evaluated.
 52 |  * @return array{command: string, pid: int, running: bool, signaled: bool, stopped: bool, exitcode: int, termsig: int, stopsig: int} An array of collected information on success. The returned array contains the following elements:
 53 |  *
 54 |  *
 55 |  *
 56 |  *
 57 |  * elementtypedescription
 58 |  *
 59 |  *
 60 |  *
 61 |  * command
 62 |  * string
 63 |  *
 64 |  * The command string that was passed to proc_open.
 65 |  *
 66 |  *
 67 |  *
 68 |  * pid
 69 |  * int
 70 |  * process id
 71 |  *
 72 |  *
 73 |  * running
 74 |  * bool
 75 |  *
 76 |  * TRUE if the process is still running, FALSE if it has
 77 |  * terminated.
 78 |  *
 79 |  *
 80 |  *
 81 |  * signaled
 82 |  * bool
 83 |  *
 84 |  * TRUE if the child process has been terminated by
 85 |  * an uncaught signal. Always set to FALSE on Windows.
 86 |  *
 87 |  *
 88 |  *
 89 |  * stopped
 90 |  * bool
 91 |  *
 92 |  * TRUE if the child process has been stopped by a
 93 |  * signal. Always set to FALSE on Windows.
 94 |  *
 95 |  *
 96 |  *
 97 |  * exitcode
 98 |  * int
 99 |  *
100 |  * The exit code returned by the process (which is only
101 |  * meaningful if running is FALSE).
102 |  * Only first call of this function return real value, next calls return
103 |  * -1.
104 |  *
105 |  *
106 |  *
107 |  * termsig
108 |  * int
109 |  *
110 |  * The number of the signal that caused the child process to terminate
111 |  * its execution (only meaningful if signaled is TRUE).
112 |  *
113 |  *
114 |  *
115 |  * stopsig
116 |  * int
117 |  *
118 |  * The number of the signal that caused the child process to stop its
119 |  * execution (only meaningful if stopped is TRUE).
120 |  *
121 |  *
122 |  *
123 |  *
124 |  *
125 |  * @throws ExecException
126 |  *
127 |  */
128 | function proc_get_status($process): array
129 | {
130 |     error_clear_last();
131 |     $result = \proc_get_status($process);
132 |     if ($result === false) {
133 |         throw ExecException::createFromPhpError();
134 |     }
135 |     return $result;
136 | }
137 | 
138 | 
139 | /**
140 |  * proc_nice changes the priority of the current
141 |  * process by the amount specified in priority. A
142 |  * positive priority will lower the priority of the
143 |  * current process, whereas a negative priority
144 |  * will raise the priority.
145 |  *
146 |  * proc_nice is not related to
147 |  * proc_open and its associated functions in any way.
148 |  *
149 |  * @param int $priority The new priority value, the value of this may differ on platforms.
150 |  *
151 |  * On Unix, a low value, such as -20 means high priority
152 |  * wheras a positive value have a lower priority.
153 |  *
154 |  * For Windows the priority parameter have the
155 |  * following meanings:
156 |  * @throws ExecException
157 |  *
158 |  */
159 | function proc_nice(int $priority): void
160 | {
161 |     error_clear_last();
162 |     $result = \proc_nice($priority);
163 |     if ($result === false) {
164 |         throw ExecException::createFromPhpError();
165 |     }
166 | }
167 | 
168 | 
169 | /**
170 |  * system is just like the C version of the
171 |  * function in that it executes the given
172 |  * command and outputs the result.
173 |  *
174 |  * The system call also tries to automatically
175 |  * flush the web server's output buffer after each line of output if
176 |  * PHP is running as a server module.
177 |  *
178 |  * If you need to execute a command and have all the data from the
179 |  * command passed directly back without any interference, use the
180 |  * passthru function.
181 |  *
182 |  * @param string $command The command that will be executed.
183 |  * @param int|null $result_code If the result_code argument is present, then the
184 |  * return status of the executed command will be written to this
185 |  * variable.
186 |  * @return string Returns the last line of the command output on success.
187 |  * @throws ExecException
188 |  *
189 |  */
190 | function system(string $command, ?int &$result_code = null): string
191 | {
192 |     error_clear_last();
193 |     $result = \system($command, $result_code);
194 |     if ($result === false) {
195 |         throw ExecException::createFromPhpError();
196 |     }
197 |     return $result;
198 | }
199 | 


--------------------------------------------------------------------------------
/generated/com.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Safe;
  4 | 
  5 | use Safe\Exceptions\ComException;
  6 | 
  7 | /**
  8 |  * Generates a Globally Unique Identifier (GUID).
  9 |  *
 10 |  * A GUID is generated in the same way as DCE UUID's, except that the
 11 |  * Microsoft convention is to enclose a GUID in curly braces.
 12 |  *
 13 |  * @return string Returns the GUID as a string.
 14 |  * @throws ComException
 15 |  *
 16 |  */
 17 | function com_create_guid(): string
 18 | {
 19 |     error_clear_last();
 20 |     $result = \com_create_guid();
 21 |     if ($result === false) {
 22 |         throw ComException::createFromPhpError();
 23 |     }
 24 |     return $result;
 25 | }
 26 | 
 27 | 
 28 | /**
 29 |  * Instructs COM to sink events generated by
 30 |  * variant into the PHP object
 31 |  * sink_object.
 32 |  *
 33 |  * Be careful how you use this feature; if you are doing something similar
 34 |  * to the example below, then it doesn't really make sense to run it in a
 35 |  * web server context.
 36 |  *
 37 |  * @param object $variant
 38 |  * @param object $sink_object sink_object should be an instance of a class with
 39 |  * methods named after those of the desired dispinterface; you may use
 40 |  * com_print_typeinfo to help generate a template class
 41 |  * for this purpose.
 42 |  * @param mixed $sink_interface PHP will attempt to use the default dispinterface type specified by
 43 |  * the typelibrary associated with variant, but
 44 |  * you may override this choice by setting
 45 |  * sink_interface to the name of the dispinterface
 46 |  * that you want to use.
 47 |  * @throws ComException
 48 |  *
 49 |  */
 50 | function com_event_sink(object $variant, object $sink_object, $sink_interface = null): void
 51 | {
 52 |     error_clear_last();
 53 |     if ($sink_interface !== null) {
 54 |         $result = \com_event_sink($variant, $sink_object, $sink_interface);
 55 |     } else {
 56 |         $result = \com_event_sink($variant, $sink_object);
 57 |     }
 58 |     if ($result === false) {
 59 |         throw ComException::createFromPhpError();
 60 |     }
 61 | }
 62 | 
 63 | 
 64 | /**
 65 |  * Loads a type-library and registers its constants in the engine, as though
 66 |  * they were defined using define.
 67 |  *
 68 |  * Note that it is much more efficient to use the  configuration setting to pre-load and
 69 |  * register the constants, although not so flexible.
 70 |  *
 71 |  * If you have turned on , then
 72 |  * PHP will attempt to automatically register the constants associated with a
 73 |  * COM object when you instantiate it.  This depends on the interfaces
 74 |  * provided by the COM object itself, and may not always be possible.
 75 |  *
 76 |  * @param string $typelib typelib can be one of the following:
 77 |  *
 78 |  *
 79 |  *
 80 |  * The filename of a .tlb file or the executable module
 81 |  * that contains the type library.
 82 |  *
 83 |  *
 84 |  *
 85 |  *
 86 |  * The type library GUID, followed by its version number, for example
 87 |  * {00000200-0000-0010-8000-00AA006D2EA4},2,0.
 88 |  *
 89 |  *
 90 |  *
 91 |  *
 92 |  * The type library name, e.g. Microsoft OLE DB ActiveX Data
 93 |  * Objects 1.0 Library.
 94 |  *
 95 |  *
 96 |  *
 97 |  * PHP will attempt to resolve the type library in this order, as the
 98 |  * process gets more and more expensive as you progress down the list;
 99 |  * searching for the type library by name is handled by physically
100 |  * enumerating the registry until we find a match.
101 |  *
102 |  * The filename of a .tlb file or the executable module
103 |  * that contains the type library.
104 |  *
105 |  * The type library GUID, followed by its version number, for example
106 |  * {00000200-0000-0010-8000-00AA006D2EA4},2,0.
107 |  *
108 |  * The type library name, e.g. Microsoft OLE DB ActiveX Data
109 |  * Objects 1.0 Library.
110 |  * @param bool $case_insensitive The case_insensitive behaves inversely to
111 |  * the parameter $case_insensitive in the define
112 |  * function.
113 |  * @throws ComException
114 |  *
115 |  */
116 | function com_load_typelib(string $typelib, bool $case_insensitive = true): void
117 | {
118 |     error_clear_last();
119 |     $result = \com_load_typelib($typelib, $case_insensitive);
120 |     if ($result === false) {
121 |         throw ComException::createFromPhpError();
122 |     }
123 | }
124 | 
125 | 
126 | /**
127 |  * The purpose of this function is to help generate a skeleton class for use
128 |  * as an event sink.  You may also use it to generate a dump of any COM
129 |  * object, provided that it supports enough of the introspection interfaces,
130 |  * and that you know the name of the interface you want to display.
131 |  *
132 |  * @param object $variant variant should be either an instance of a COM
133 |  * object, or be the name of a typelibrary (which will be resolved according
134 |  * to the rules set out in com_load_typelib).
135 |  * @param string $dispatch_interface The name of an IDispatch descendant interface that you want to display.
136 |  * @param bool $display_sink If set to TRUE, the corresponding sink interface will be displayed
137 |  * instead.
138 |  * @throws ComException
139 |  *
140 |  */
141 | function com_print_typeinfo(object $variant, string $dispatch_interface = null, bool $display_sink = false): void
142 | {
143 |     error_clear_last();
144 |     if ($display_sink !== false) {
145 |         $result = \com_print_typeinfo($variant, $dispatch_interface, $display_sink);
146 |     } elseif ($dispatch_interface !== null) {
147 |         $result = \com_print_typeinfo($variant, $dispatch_interface);
148 |     } else {
149 |         $result = \com_print_typeinfo($variant);
150 |     }
151 |     if ($result === false) {
152 |         throw ComException::createFromPhpError();
153 |     }
154 | }
155 | 
156 | 
157 | /**
158 |  * Converts variant from a VT_DATE
159 |  * (or similar) value into a Unix timestamp.  This allows easier
160 |  * interopability between the Unix-ish parts of PHP and COM.
161 |  *
162 |  * @param object $variant The variant.
163 |  * @return int Returns a unix timestamp.
164 |  * @throws ComException
165 |  *
166 |  */
167 | function variant_date_to_timestamp(object $variant): int
168 | {
169 |     error_clear_last();
170 |     $result = \variant_date_to_timestamp($variant);
171 |     if ($result === null) {
172 |         throw ComException::createFromPhpError();
173 |     }
174 |     return $result;
175 | }
176 | 
177 | 
178 | /**
179 |  * Returns the value of value rounded to
180 |  * decimals decimal places.
181 |  *
182 |  * @param mixed $value The variant.
183 |  * @param int $decimals Number of decimal places.
184 |  * @return mixed Returns the rounded value.
185 |  * @throws ComException
186 |  *
187 |  */
188 | function variant_round($value, int $decimals)
189 | {
190 |     error_clear_last();
191 |     $result = \variant_round($value, $decimals);
192 |     if ($result === null) {
193 |         throw ComException::createFromPhpError();
194 |     }
195 |     return $result;
196 | }
197 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | [![Latest Stable Version](https://poser.pugx.org/thecodingmachine/safe/v/stable.svg)](https://packagist.org/packages/thecodingmachine/safe)
  2 | [![Total Downloads](https://poser.pugx.org/thecodingmachine/safe/downloads.svg)](https://packagist.org/packages/thecodingmachine/safe)
  3 | [![Latest Unstable Version](https://poser.pugx.org/thecodingmachine/safe/v/unstable.svg)](https://packagist.org/packages/thecodingmachine/safe)
  4 | [![License](https://poser.pugx.org/thecodingmachine/safe/license.svg)](https://packagist.org/packages/thecodingmachine/safe)
  5 | [![Build Status](https://travis-ci.org/thecodingmachine/safe.svg?branch=master)](https://travis-ci.org/thecodingmachine/safe)
  6 | [![Continuous Integration](https://github.com/thecodingmachine/safe/workflows/Continuous%20Integration/badge.svg)](https://github.com/thecodingmachine/safe/actions)
  7 | [![codecov](https://codecov.io/gh/thecodingmachine/safe/branch/master/graph/badge.svg)](https://codecov.io/gh/thecodingmachine/safe)
  8 | 
  9 | Safe PHP
 10 | ========
 11 | 
 12 | ---
 13 | 📌 **Deprecation Notice**
 14 | 
 15 | This repository is deprecated and no more work will be done on this by The Coding Machine. You can use instead [safe v2](https://github.com/thecodingmachine/safe) for same usage. 
 16 | 
 17 | ---
 18 | 
 19 | **Work in progress**
 20 | 
 21 | A set of core PHP functions rewritten to throw exceptions instead of returning `false` when an error is encountered.
 22 | 
 23 | ## The problem
 24 | 
 25 | Most PHP core functions were written before exception handling was added to the language. Therefore, most PHP functions
 26 | do not throw exceptions. Instead, they return `false` in case of error.
 27 | 
 28 | But most of us are too lazy to check explicitly for every single return of every core PHP function.
 29 | 
 30 | ```php
 31 | // This code is incorrect. Twice.
 32 | // "file_get_contents" can return false if the file does not exists
 33 | // "json_decode" can return false if the file content is not valid JSON
 34 | $content = file_get_contents('foobar.json');
 35 | $foobar = json_decode($content);
 36 | ```
 37 | 
 38 | The correct version of this code would be:
 39 | 
 40 | ```php
 41 | $content = file_get_contents('foobar.json');
 42 | if ($content === false) {
 43 |     throw new FileLoadingException('Could not load file foobar.json');
 44 | }
 45 | $foobar = json_decode($content);
 46 | if (json_last_error() !== JSON_ERROR_NONE) {
 47 |     throw new FileLoadingException('foobar.json does not contain valid JSON: '.json_last_error_msg());
 48 | }
 49 | ```
 50 | 
 51 | Obviously, while this snippet is correct, it is less easy to read.
 52 | 
 53 | ## The solution
 54 | 
 55 | Enter *thecodingmachine/safe* aka Safe-PHP.
 56 | 
 57 | Safe-PHP redeclares all core PHP functions. The new PHP functions act exactly as the old ones, except they
 58 | throw exceptions properly when an error is encountered. The "safe" functions have the same name as the core PHP
 59 | functions, except they are in the `Safe` namespace.
 60 | 
 61 | ```php
 62 | use function Safe\file_get_contents;
 63 | use function Safe\json_decode;
 64 | 
 65 | // This code is both safe and simple!
 66 | $content = file_get_contents('foobar.json');
 67 | $foobar = json_decode($content);
 68 | ```
 69 | 
 70 | All PHP functions that can return `false` on error are part of Safe.
 71 | In addition, Safe also provide 2 'Safe' classes: `Safe\DateTime` and `Safe\DateTimeImmutable` whose methods will throw exceptions instead of returning false.
 72 | 
 73 | ## PHPStan integration
 74 | 
 75 | > Yeah... but I must explicitly think about importing the "safe" variant of the function, for each and every file of my application.
 76 | > I'm sure I will forget some "use function" statements!
 77 | 
 78 | Fear not! thecodingmachine/safe comes with a PHPStan rule.
 79 | 
 80 | Never heard of [PHPStan](https://github.com/phpstan/phpstan) before?
 81 | Check it out, it's an amazing code analyzer for PHP.
 82 | 
 83 | Simply install the Safe rule in your PHPStan setup (explained in the "Installation" section) and PHPStan will let you know each time you are using an "unsafe" function.
 84 | 
 85 | The code below will trigger this warning:
 86 | 
 87 | ```php
 88 | $content = file_get_contents('foobar.json');
 89 | ```
 90 | 
 91 | > Function file_get_contents is unsafe to use. It can return FALSE instead of throwing an exception. Please add 'use function Safe\\file_get_contents;' at the beginning of the file to use the variant provided by the 'thecodingmachine/safe' library.
 92 | 
 93 | ## Installation
 94 | 
 95 | Use composer to install Safe-PHP:
 96 | 
 97 | ```bash
 98 | $ composer require thecodingmachine/safe
 99 | ```
100 | 
101 | *Highly recommended*: install PHPStan and PHPStan extension:
102 | 
103 | ```bash
104 | $ composer require --dev thecodingmachine/phpstan-safe-rule
105 | ```
106 | 
107 | Now, edit your `phpstan.neon` file and add these rules:
108 | 
109 | ```yml
110 | includes:
111 |     - vendor/thecodingmachine/phpstan-safe-rule/phpstan-safe-rule.neon
112 | ```
113 | 
114 | ## Automated refactoring
115 | 
116 | You have a large legacy codebase and want to use "Safe-PHP" functions throughout your project? PHPStan will help you
117 | find these functions but changing the namespace of the functions one function at a time might be a tedious task.
118 | 
119 | Fortunately, Safe comes bundled with a "Rector" configuration file. [Rector](https://github.com/rectorphp/rector) is a command-line
120 | tool that performs instant refactoring of your application.
121 | 
122 | Run
123 | 
124 | ```bash
125 | $ composer require --dev rector/rector:^0.7
126 | ```
127 | 
128 | to install `rector/rector`.
129 | 
130 | Run
131 | 
132 | ```bash
133 | vendor/bin/rector process src/ --config vendor/thecodingmachine/safe/rector-migrate-0.7.php
134 | ```
135 | 
136 | to run `rector/rector`.
137 | 
138 | *Note:* do not forget to replace "src/" with the path to your source directory.
139 | 
140 | **Important:** the refactoring only performs a "dumb" replacement of functions. It will not modify the way
141 | "false" return values are handled. So if your code was already performing error handling, you will have to deal
142 | with it manually.
143 | 
144 | Especially, you should look for error handling that was already performed, like:
145 | 
146 | ```php
147 | if (!mkdir($dirPath)) {
148 |     // Do something on error
149 | }
150 | ```
151 | 
152 | This code will be refactored by Rector to:
153 | 
154 | ```php
155 | if (!\Safe\mkdir($dirPath)) {
156 |     // Do something on error
157 | }
158 | ```
159 | 
160 | You should then (manually) refactor it to:
161 | 
162 | ```php
163 | try {
164 |     \Safe\mkdir($dirPath));
165 | } catch (\Safe\FilesystemException $e) {
166 |     // Do something on error
167 | }
168 | ```
169 | 
170 | ## Performance impact
171 | 
172 | Safe is loading 1000+ functions from ~85 files on each request. Yet, the performance impact of this loading is quite low.
173 | 
174 | In case you worry, using Safe will "cost" you ~700µs on each request. The [performance section](performance/README.md)
175 | contains more information regarding the way we tested the performance impact of Safe.
176 | 
177 | ## Learn more
178 | 
179 | Read [the release article on TheCodingMachine's blog](https://thecodingmachine.io/introducing-safe-php) if you want to
180 | learn more about what triggered the development of Safe-PHP.
181 | 
182 | ## Contributing
183 | 
184 | The files that contain all the functions are auto-generated from the PHP doc.
185 | Read the [CONTRIBUTING.md](CONTRIBUTING.md) file to learn how to regenerate these files and to contribute to this library.
186 | 


--------------------------------------------------------------------------------
/deprecated/apc.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Safe;
  4 | 
  5 | use Safe\Exceptions\ApcException;
  6 | 
  7 | /**
  8 |  * Retrieves cached information and meta-data from APC's data store.
  9 |  *
 10 |  * @param string $cache_type If cache_type is "user",
 11 |  * information about the user cache will be returned.
 12 |  *
 13 |  * If cache_type is "filehits",
 14 |  * information about which files have been served from the bytecode cache
 15 |  * for the current request will be returned. This feature must be enabled at
 16 |  * compile time using --enable-filehits.
 17 |  *
 18 |  * If an invalid or no cache_type is specified, information about
 19 |  * the system cache (cached files) will be returned.
 20 |  * @param bool $limited If limited is TRUE, the
 21 |  * return value will exclude the individual list of cache entries.  This
 22 |  * is useful when trying to optimize calls for statistics gathering.
 23 |  * @return array Array of cached data (and meta-data)
 24 |  * @throws ApcException
 25 |  *
 26 |  */
 27 | function apc_cache_info(string $cache_type = '', bool $limited = false): array
 28 | {
 29 |     error_clear_last();
 30 |     $result = \apc_cache_info($cache_type, $limited);
 31 |     if ($result === false) {
 32 |         throw ApcException::createFromPhpError();
 33 |     }
 34 |     return $result;
 35 | }
 36 | 
 37 | 
 38 | /**
 39 |  * apc_cas updates an already existing integer value if the
 40 |  * old parameter matches the currently stored value
 41 |  * with the value of the new parameter.
 42 |  *
 43 |  * @param string $key The key of the value being updated.
 44 |  * @param int $old The old value (the value currently stored).
 45 |  * @param int $new The new value to update to.
 46 |  * @throws ApcException
 47 |  *
 48 |  */
 49 | function apc_cas(string $key, int $old, int $new): void
 50 | {
 51 |     error_clear_last();
 52 |     $result = \apc_cas($key, $old, $new);
 53 |     if ($result === false) {
 54 |         throw ApcException::createFromPhpError();
 55 |     }
 56 | }
 57 | 
 58 | 
 59 | /**
 60 |  * Stores a file in the bytecode cache, bypassing all filters.
 61 |  *
 62 |  * @param string $filename Full or relative path to a PHP file that will be compiled and stored in
 63 |  * the bytecode cache.
 64 |  * @param bool $atomic
 65 |  * @return mixed Returns TRUE on success.
 66 |  * @throws ApcException
 67 |  *
 68 |  */
 69 | function apc_compile_file(string $filename, bool $atomic = true)
 70 | {
 71 |     error_clear_last();
 72 |     $result = \apc_compile_file($filename, $atomic);
 73 |     if ($result === false) {
 74 |         throw ApcException::createFromPhpError();
 75 |     }
 76 |     return $result;
 77 | }
 78 | 
 79 | 
 80 | /**
 81 |  * Decreases a stored integer value.
 82 |  *
 83 |  * @param string $key The key of the value being decreased.
 84 |  * @param int $step The step, or value to decrease.
 85 |  * @param bool|null $success Optionally pass the success or fail boolean value to
 86 |  * this referenced variable.
 87 |  * @return int Returns the current value of key's value on success
 88 |  * @throws ApcException
 89 |  *
 90 |  */
 91 | function apc_dec(string $key, int $step = 1, ?bool &$success = null): int
 92 | {
 93 |     error_clear_last();
 94 |     $result = \apc_dec($key, $step, $success);
 95 |     if ($result === false) {
 96 |         throw ApcException::createFromPhpError();
 97 |     }
 98 |     return $result;
 99 | }
100 | 
101 | 
102 | /**
103 |  * define is notoriously slow. Since the main benefit of
104 |  * APC is to increase the performance of scripts/applications, this mechanism
105 |  * is provided to streamline the process of mass constant definition. However,
106 |  * this function does not perform as well as anticipated.
107 |  *
108 |  * For a better-performing solution, try the
109 |  * hidef extension from PECL.
110 |  *
111 |  * @param string $key The key serves as the name of the constant set
112 |  * being stored. This key is used to retrieve the
113 |  * stored constants in apc_load_constants.
114 |  * @param array $constants An associative array of constant_name =&gt; value
115 |  * pairs. The constant_name must follow the normal
116 |  * constant naming rules.
117 |  * value must evaluate to a scalar value.
118 |  * @param bool $case_sensitive The default behaviour for constants is to be declared case-sensitive;
119 |  * i.e. CONSTANT and Constant
120 |  * represent different values. If this parameter evaluates to FALSE the
121 |  * constants will be declared as case-insensitive symbols.
122 |  * @throws ApcException
123 |  *
124 |  */
125 | function apc_define_constants(string $key, array $constants, bool $case_sensitive = true): void
126 | {
127 |     error_clear_last();
128 |     $result = \apc_define_constants($key, $constants, $case_sensitive);
129 |     if ($result === false) {
130 |         throw ApcException::createFromPhpError();
131 |     }
132 | }
133 | 
134 | 
135 | /**
136 |  * Deletes the given files from the opcode cache.
137 |  *
138 |  * @param mixed $keys The files to be deleted. Accepts a string,
139 |  * array of strings, or an APCIterator
140 |  * object.
141 |  * @return mixed Returns TRUE on success.
142 |  * Or if keys is an array, then
143 |  * an empty array is returned on success, or an array of failed files
144 |  * is returned.
145 |  * @throws ApcException
146 |  *
147 |  */
148 | function apc_delete_file($keys)
149 | {
150 |     error_clear_last();
151 |     $result = \apc_delete_file($keys);
152 |     if ($result === false) {
153 |         throw ApcException::createFromPhpError();
154 |     }
155 |     return $result;
156 | }
157 | 
158 | 
159 | /**
160 |  * Removes a stored variable from the cache.
161 |  *
162 |  * @param string|string[]|\APCIterator $key The key used to store the value (with
163 |  * apc_store).
164 |  * @throws ApcException
165 |  *
166 |  */
167 | function apc_delete($key): void
168 | {
169 |     error_clear_last();
170 |     $result = \apc_delete($key);
171 |     if ($result === false) {
172 |         throw ApcException::createFromPhpError();
173 |     }
174 | }
175 | 
176 | 
177 | /**
178 |  * Increases a stored number.
179 |  *
180 |  * @param string $key The key of the value being increased.
181 |  * @param int $step The step, or value to increase.
182 |  * @param bool|null $success Optionally pass the success or fail boolean value to
183 |  * this referenced variable.
184 |  * @return int Returns the current value of key's value on success
185 |  * @throws ApcException
186 |  *
187 |  */
188 | function apc_inc(string $key, int $step = 1, ?bool &$success = null): int
189 | {
190 |     error_clear_last();
191 |     $result = \apc_inc($key, $step, $success);
192 |     if ($result === false) {
193 |         throw ApcException::createFromPhpError();
194 |     }
195 |     return $result;
196 | }
197 | 
198 | 
199 | /**
200 |  * Loads a set of constants from the cache.
201 |  *
202 |  * @param string $key The name of the constant set (that was stored with
203 |  * apc_define_constants) to be retrieved.
204 |  * @param bool $case_sensitive The default behaviour for constants is to be declared case-sensitive;
205 |  * i.e. CONSTANT and Constant
206 |  * represent different values. If this parameter evaluates to FALSE the
207 |  * constants will be declared as case-insensitive symbols.
208 |  * @throws ApcException
209 |  *
210 |  */
211 | function apc_load_constants(string $key, bool $case_sensitive = true): void
212 | {
213 |     error_clear_last();
214 |     $result = \apc_load_constants($key, $case_sensitive);
215 |     if ($result === false) {
216 |         throw ApcException::createFromPhpError();
217 |     }
218 | }
219 | 
220 | 
221 | /**
222 |  * Retrieves APC's Shared Memory Allocation information.
223 |  *
224 |  * @param bool $limited When set to FALSE (default) apc_sma_info will
225 |  * return a detailed information about each segment.
226 |  * @return array Array of Shared Memory Allocation data; FALSE on failure.
227 |  * @throws ApcException
228 |  *
229 |  */
230 | function apc_sma_info(bool $limited = false): array
231 | {
232 |     error_clear_last();
233 |     $result = \apc_sma_info($limited);
234 |     if ($result === false) {
235 |         throw ApcException::createFromPhpError();
236 |     }
237 |     return $result;
238 | }
239 | 


--------------------------------------------------------------------------------
/lib/DateTimeImmutable.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Safe;
  4 | 
  5 | use DateInterval;
  6 | use DateTime;
  7 | use DateTimeInterface;
  8 | use DateTimeZone;
  9 | use Safe\Exceptions\DatetimeException;
 10 | 
 11 | /**
 12 |  * This class is used to implement a safe version of the DatetimeImmutable class.
 13 |  * While it technically overloads \DateTimeImmutable for typehint compatibility,
 14 |  * it is actually used as a wrapper of \DateTimeImmutable, mostly to be able to overwrite functions like getTimestamp() while still being able to edit milliseconds via setTime().
 15 |  */
 16 | class DateTimeImmutable extends \DateTimeImmutable
 17 | {
 18 |     /**
 19 |      * @var \DateTimeImmutable
 20 |      */
 21 |     private $innerDateTime;
 22 | 
 23 |     /**
 24 |      * DateTimeImmutable constructor.
 25 |      * @param string $time
 26 |      * @param DateTimeZone|null $timezone
 27 |      * @throws \Exception
 28 |      */
 29 |     public function __construct($time = 'now', $timezone = null)
 30 |     {
 31 |         parent::__construct($time, $timezone);
 32 |         $this->innerDateTime = new parent($time, $timezone);
 33 |     }
 34 | 
 35 |     //switch between regular datetime and safe version
 36 |     public static function createFromRegular(\DateTimeImmutable $datetime): self
 37 |     {
 38 |         $safeDatetime = new self($datetime->format('Y-m-d H:i:s.u'), $datetime->getTimezone()); //we need to also update the wrapper to not break the operators '<' and '>'
 39 |         $safeDatetime->innerDateTime = $datetime; //to make sure we don't lose information because of the format().
 40 |         return $safeDatetime;
 41 |     }
 42 | 
 43 |     //usefull if you need to switch back to regular DateTimeImmutable (for example when using DatePeriod)
 44 |     public function getInnerDateTime(): \DateTimeImmutable
 45 |     {
 46 |         return $this->innerDateTime;
 47 |     }
 48 | 
 49 |     /////////////////////////////////////////////////////////////////////////////
 50 |     // overload functions with false errors
 51 | 
 52 |     /**
 53 |      * @param string $format
 54 |      * @param string $time
 55 |      * @param DateTimeZone|null $timezone
 56 |      * @throws DatetimeException
 57 |      */
 58 |     public static function createFromFormat($format, $time, $timezone = null)
 59 |     {
 60 |         $datetime = \DateTimeImmutable::createFromFormat($format, $time, $timezone);
 61 |         if ($datetime === false) {
 62 |             throw DatetimeException::createFromPhpError();
 63 |         }
 64 |         return self::createFromRegular($datetime);
 65 |     }
 66 | 
 67 |     /**
 68 |      * @param string $format
 69 |      * @return string
 70 |      * @throws DatetimeException
 71 |      */
 72 |     public function format($format): string
 73 |     {
 74 |         /** @var string|false $result */
 75 |         $result = $this->innerDateTime->format($format);
 76 |         if ($result === false) {
 77 |             throw DatetimeException::createFromPhpError();
 78 |         }
 79 |         return $result;
 80 |     }
 81 | 
 82 |     /**
 83 |      * @param DateTimeInterface $datetime2
 84 |      * @param bool $absolute
 85 |      * @return DateInterval
 86 |      * @throws DatetimeException
 87 |      */
 88 |     public function diff($datetime2, $absolute = false): DateInterval
 89 |     {
 90 |         /** @var \DateInterval|false $result */
 91 |         $result = $this->innerDateTime->diff($datetime2, $absolute);
 92 |         if ($result === false) {
 93 |             throw DatetimeException::createFromPhpError();
 94 |         }
 95 |         return $result;
 96 |     }
 97 | 
 98 |     /**
 99 |      * @param string $modify
100 |      * @return DateTimeImmutable
101 |      * @throws DatetimeException
102 |      */
103 |     public function modify($modify): self
104 |     {
105 |         /** @var \DateTimeImmutable|false $result */
106 |         $result = $this->innerDateTime->modify($modify);
107 |         if ($result === false) {
108 |             throw DatetimeException::createFromPhpError();
109 |         }
110 |         return self::createFromRegular($result); //we have to recreate a safe datetime because modify create a new instance of \DateTimeImmutable
111 |     }
112 | 
113 |     /**
114 |      * @param int $year
115 |      * @param int $month
116 |      * @param int $day
117 |      * @return DateTimeImmutable
118 |      * @throws DatetimeException
119 |      */
120 |     public function setDate($year, $month, $day): self
121 |     {
122 |         /** @var \DateTimeImmutable|false $result */
123 |         $result = $this->innerDateTime->setDate($year, $month, $day);
124 |         if ($result === false) {
125 |             throw DatetimeException::createFromPhpError();
126 |         }
127 |         return self::createFromRegular($result); //we have to recreate a safe datetime because modify create a new instance of \DateTimeImmutable
128 |     }
129 | 
130 |     /**
131 |      * @param int $year
132 |      * @param int $week
133 |      * @param int $day
134 |      * @return DateTimeImmutable
135 |      * @throws DatetimeException
136 |      */
137 |     public function setISODate($year, $week, $day = 1): self
138 |     {
139 |         /** @var \DateTimeImmutable|false $result */
140 |         $result = $this->innerDateTime->setISODate($year, $week, $day);
141 |         if ($result === false) {
142 |             throw DatetimeException::createFromPhpError();
143 |         }
144 |         return self::createFromRegular($result); //we have to recreate a safe datetime because modify create a new instance of \DateTimeImmutable
145 |     }
146 | 
147 |     /**
148 |      * @param int $hour
149 |      * @param int $minute
150 |      * @param int $second
151 |      * @param int $microseconds
152 |      * @return DateTimeImmutable
153 |      * @throws DatetimeException
154 |      */
155 |     public function setTime($hour, $minute, $second = 0, $microseconds = 0): self
156 |     {
157 |         /** @var \DateTimeImmutable|false $result */
158 |         $result = $this->innerDateTime->setTime($hour, $minute, $second, $microseconds);
159 |         if ($result === false) {
160 |             throw DatetimeException::createFromPhpError();
161 |         }
162 |         return self::createFromRegular($result);
163 |     }
164 | 
165 |     /**
166 |      * @param int $unixtimestamp
167 |      * @return DateTimeImmutable
168 |      * @throws DatetimeException
169 |      */
170 |     public function setTimestamp($unixtimestamp): self
171 |     {
172 |         /** @var \DateTimeImmutable|false $result */
173 |         $result = $this->innerDateTime->setTimestamp($unixtimestamp);
174 |         if ($result === false) {
175 |             throw DatetimeException::createFromPhpError();
176 |         }
177 |         return self::createFromRegular($result);
178 |     }
179 | 
180 |     /**
181 |      * @param DateTimeZone $timezone
182 |      * @return DateTimeImmutable
183 |      * @throws DatetimeException
184 |      */
185 |     public function setTimezone($timezone): self
186 |     {
187 |         /** @var \DateTimeImmutable|false $result */
188 |         $result = $this->innerDateTime->setTimezone($timezone);
189 |         if ($result === false) {
190 |             throw DatetimeException::createFromPhpError();
191 |         }
192 |         return self::createFromRegular($result);
193 |     }
194 | 
195 |     /**
196 |      * @param DateInterval $interval
197 |      * @return DateTimeImmutable
198 |      * @throws DatetimeException
199 |      */
200 |     public function sub($interval): self
201 |     {
202 |         /** @var \DateTimeImmutable|false $result */
203 |         $result = $this->innerDateTime->sub($interval);
204 |         if ($result === false) {
205 |             throw DatetimeException::createFromPhpError();
206 |         }
207 |         return self::createFromRegular($result);
208 |     }
209 | 
210 |     /**
211 |      * @throws DatetimeException
212 |      */
213 |     public function getOffset(): int
214 |     {
215 |         /** @var int|false $result */
216 |         $result = $this->innerDateTime->getOffset();
217 |         if ($result === false) {
218 |             throw DatetimeException::createFromPhpError();
219 |         }
220 |         return $result;
221 |     }
222 | 
223 |     //////////////////////////////////////////////////////////////////////////////////////////
224 |     //overload getters to use the inner datetime immutable instead of itself
225 | 
226 |     /**
227 |      * @param DateInterval $interval
228 |      * @return DateTimeImmutable
229 |      */
230 |     public function add($interval): self
231 |     {
232 |         return self::createFromRegular($this->innerDateTime->add($interval));
233 |     }
234 | 
235 |     /**
236 |      * @param DateTime $dateTime
237 |      * @return DateTimeImmutable
238 |      */
239 |     public static function createFromMutable($dateTime): self
240 |     {
241 |         return self::createFromRegular(parent::createFromMutable($dateTime));
242 |     }
243 | 
244 |     /**
245 |      * @param mixed[] $array
246 |      * @return DateTimeImmutable
247 |      */
248 |     public static function __set_state($array): self
249 |     {
250 |         return self::createFromRegular(parent::__set_state($array));
251 |     }
252 | 
253 |     public function getTimezone(): DateTimeZone
254 |     {
255 |         return $this->innerDateTime->getTimezone();
256 |     }
257 | 
258 |     public function getTimestamp(): int
259 |     {
260 |         return $this->innerDateTime->getTimestamp();
261 |     }
262 | }
263 | 


--------------------------------------------------------------------------------
/generated/xdiff.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Safe;
  4 | 
  5 | use Safe\Exceptions\XdiffException;
  6 | 
  7 | /**
  8 |  * Makes a binary diff of two files and stores the result in a patch file.
  9 |  * This function works with both text and binary files. Resulting patch
 10 |  * file can be later applied using xdiff_file_bpatch/xdiff_string_bpatch.
 11 |  *
 12 |  * @param string $old_file Path to the first file. This file acts as "old" file.
 13 |  * @param string $new_file Path to the second file. This file acts as "new" file.
 14 |  * @param string $dest Path of the resulting patch file. Resulting file contains differences
 15 |  * between "old" and "new" files. It is in binary format and is human-unreadable.
 16 |  * @throws XdiffException
 17 |  *
 18 |  */
 19 | function xdiff_file_bdiff(string $old_file, string $new_file, string $dest): void
 20 | {
 21 |     error_clear_last();
 22 |     $result = \xdiff_file_bdiff($old_file, $new_file, $dest);
 23 |     if ($result === false) {
 24 |         throw XdiffException::createFromPhpError();
 25 |     }
 26 | }
 27 | 
 28 | 
 29 | /**
 30 |  * Patches a file with a binary
 31 |  * patch and stores the result in a file dest.
 32 |  * This function accepts patches created both via xdiff_file_bdiff
 33 |  * and xdiff_file_rabdiff functions or their string counterparts.
 34 |  *
 35 |  * @param string $file The original file.
 36 |  * @param string $patch The binary patch file.
 37 |  * @param string $dest Path of the resulting file.
 38 |  * @throws XdiffException
 39 |  *
 40 |  */
 41 | function xdiff_file_bpatch(string $file, string $patch, string $dest): void
 42 | {
 43 |     error_clear_last();
 44 |     $result = \xdiff_file_bpatch($file, $patch, $dest);
 45 |     if ($result === false) {
 46 |         throw XdiffException::createFromPhpError();
 47 |     }
 48 | }
 49 | 
 50 | 
 51 | /**
 52 |  * Makes a binary diff of two files and stores the result in a patch file.
 53 |  * This function works with both text and binary files. Resulting patch
 54 |  * file can be later applied using xdiff_file_bpatch.
 55 |  *
 56 |  * Starting with version 1.5.0 this function is an alias of xdiff_file_bdiff.
 57 |  *
 58 |  * @param string $old_file Path to the first file. This file acts as "old" file.
 59 |  * @param string $new_file Path to the second file. This file acts as "new" file.
 60 |  * @param string $dest Path of the resulting patch file. Resulting file contains differences
 61 |  * between "old" and "new" files. It is in binary format and is human-unreadable.
 62 |  * @throws XdiffException
 63 |  *
 64 |  */
 65 | function xdiff_file_diff_binary(string $old_file, string $new_file, string $dest): void
 66 | {
 67 |     error_clear_last();
 68 |     $result = \xdiff_file_diff_binary($old_file, $new_file, $dest);
 69 |     if ($result === false) {
 70 |         throw XdiffException::createFromPhpError();
 71 |     }
 72 | }
 73 | 
 74 | 
 75 | /**
 76 |  * Makes an unified diff containing differences between old_file and
 77 |  * new_file and stores it in dest file. The
 78 |  * resulting file is human-readable. An optional context parameter
 79 |  * specifies how many lines of context should be added around each change.
 80 |  * Setting minimal parameter to true will result in outputting the shortest
 81 |  * patch file possible (can take a long time).
 82 |  *
 83 |  * @param string $old_file Path to the first file. This file acts as "old" file.
 84 |  * @param string $new_file Path to the second file. This file acts as "new" file.
 85 |  * @param string $dest Path of the resulting patch file.
 86 |  * @param int $context Indicates how many lines of context you want to include in diff
 87 |  * result.
 88 |  * @param bool $minimal Set this parameter to TRUE if you want to minimalize size of the result
 89 |  * (can take a long time).
 90 |  * @throws XdiffException
 91 |  *
 92 |  */
 93 | function xdiff_file_diff(string $old_file, string $new_file, string $dest, int $context = 3, bool $minimal = false): void
 94 | {
 95 |     error_clear_last();
 96 |     $result = \xdiff_file_diff($old_file, $new_file, $dest, $context, $minimal);
 97 |     if ($result === false) {
 98 |         throw XdiffException::createFromPhpError();
 99 |     }
100 | }
101 | 
102 | 
103 | /**
104 |  * Patches a file with a binary
105 |  * patch and stores the result in a file dest.
106 |  * This function accepts patches created both via xdiff_file_bdiff
107 |  * or xdiff_file_rabdiff functions or their string counterparts.
108 |  *
109 |  * Starting with version 1.5.0 this function is an alias of xdiff_file_bpatch.
110 |  *
111 |  * @param string $file The original file.
112 |  * @param string $patch The binary patch file.
113 |  * @param string $dest Path of the resulting file.
114 |  * @throws XdiffException
115 |  *
116 |  */
117 | function xdiff_file_patch_binary(string $file, string $patch, string $dest): void
118 | {
119 |     error_clear_last();
120 |     $result = \xdiff_file_patch_binary($file, $patch, $dest);
121 |     if ($result === false) {
122 |         throw XdiffException::createFromPhpError();
123 |     }
124 | }
125 | 
126 | 
127 | /**
128 |  * Makes a binary diff of two files and stores the result in a patch file.
129 |  * The difference between this function and xdiff_file_bdiff is different
130 |  * algorithm used which should result in faster execution and smaller diff produced.
131 |  * This function works with both text and binary files. Resulting patch
132 |  * file can be later applied using xdiff_file_bpatch/xdiff_string_bpatch.
133 |  *
134 |  * For more details about differences between algorithm used please check libxdiff
135 |  * website.
136 |  *
137 |  * @param string $old_file Path to the first file. This file acts as "old" file.
138 |  * @param string $new_file Path to the second file. This file acts as "new" file.
139 |  * @param string $dest Path of the resulting patch file. Resulting file contains differences
140 |  * between "old" and "new" files. It is in binary format and is human-unreadable.
141 |  * @throws XdiffException
142 |  *
143 |  */
144 | function xdiff_file_rabdiff(string $old_file, string $new_file, string $dest): void
145 | {
146 |     error_clear_last();
147 |     $result = \xdiff_file_rabdiff($old_file, $new_file, $dest);
148 |     if ($result === false) {
149 |         throw XdiffException::createFromPhpError();
150 |     }
151 | }
152 | 
153 | 
154 | /**
155 |  * Patches a string str with a binary patch.
156 |  * This function accepts patches created both via xdiff_string_bdiff
157 |  * and xdiff_string_rabdiff functions or their file counterparts.
158 |  *
159 |  * @param string $str The original binary string.
160 |  * @param string $patch The binary patch string.
161 |  * @return string Returns the patched string.
162 |  * @throws XdiffException
163 |  *
164 |  */
165 | function xdiff_string_bpatch(string $str, string $patch): string
166 | {
167 |     error_clear_last();
168 |     $result = \xdiff_string_bpatch($str, $patch);
169 |     if ($result === false) {
170 |         throw XdiffException::createFromPhpError();
171 |     }
172 |     return $result;
173 | }
174 | 
175 | 
176 | /**
177 |  * Patches a string str with a binary patch.
178 |  * This function accepts patches created both via xdiff_string_bdiff
179 |  * and xdiff_string_rabdiff functions or their file counterparts.
180 |  *
181 |  * Starting with version 1.5.0 this function is an alias of xdiff_string_bpatch.
182 |  *
183 |  * @param string $str The original binary string.
184 |  * @param string $patch The binary patch string.
185 |  * @return string Returns the patched string.
186 |  * @throws XdiffException
187 |  *
188 |  */
189 | function xdiff_string_patch_binary(string $str, string $patch): string
190 | {
191 |     error_clear_last();
192 |     $result = \xdiff_string_patch_binary($str, $patch);
193 |     if ($result === false) {
194 |         throw XdiffException::createFromPhpError();
195 |     }
196 |     return $result;
197 | }
198 | 
199 | 
200 | /**
201 |  * Patches a str string with an unified patch in patch parameter
202 |  * and returns the result. patch has to be an unified diff created by
203 |  * xdiff_file_diff/xdiff_string_diff function.
204 |  * An optional flags parameter specifies mode of operation. Any
205 |  * rejected parts of the patch will be stored inside error variable if
206 |  * it is provided.
207 |  *
208 |  * @param string $str The original string.
209 |  * @param string $patch The unified patch string. It has to be created using xdiff_string_diff,
210 |  * xdiff_file_diff functions or compatible tools.
211 |  * @param int $flags flags can be either
212 |  * XDIFF_PATCH_NORMAL (default mode, normal patch)
213 |  * or XDIFF_PATCH_REVERSE (reversed patch).
214 |  *
215 |  * Starting from version 1.5.0, you can also use binary OR to enable
216 |  * XDIFF_PATCH_IGNORESPACE flag.
217 |  * @param string|null $error If provided then rejected parts are stored inside this variable.
218 |  * @return string Returns the patched string.
219 |  * @throws XdiffException
220 |  *
221 |  */
222 | function xdiff_string_patch(string $str, string $patch, int $flags = null, ?string &$error = null): string
223 | {
224 |     error_clear_last();
225 |     if ($error !== null) {
226 |         $result = \xdiff_string_patch($str, $patch, $flags, $error);
227 |     } elseif ($flags !== null) {
228 |         $result = \xdiff_string_patch($str, $patch, $flags);
229 |     } else {
230 |         $result = \xdiff_string_patch($str, $patch);
231 |     }
232 |     if ($result === false) {
233 |         throw XdiffException::createFromPhpError();
234 |     }
235 |     return $result;
236 | }
237 | 


--------------------------------------------------------------------------------