diff options
Diffstat (limited to 'vendor/thecodingmachine/safe/generated/stream.php')
| -rw-r--r-- | vendor/thecodingmachine/safe/generated/stream.php | 609 |
1 files changed, 609 insertions, 0 deletions
diff --git a/vendor/thecodingmachine/safe/generated/stream.php b/vendor/thecodingmachine/safe/generated/stream.php new file mode 100644 index 000000000..573d0295a --- /dev/null +++ b/vendor/thecodingmachine/safe/generated/stream.php @@ -0,0 +1,609 @@ +<?php + +namespace Safe; + +use Safe\Exceptions\StreamException; + +/** + * Sets parameters on the specified context. + * + * @param resource $stream_or_context The stream or context to apply the parameters too. + * @param array $params An array of parameters to set. + * + * params should be an associative array of the structure: + * $params['paramname'] = "paramvalue";. + * @throws StreamException + * + */ +function stream_context_set_params($stream_or_context, array $params): void +{ + error_clear_last(); + $result = \stream_context_set_params($stream_or_context, $params); + if ($result === false) { + throw StreamException::createFromPhpError(); + } +} + + +/** + * Makes a copy of up to maxlength bytes + * of data from the current position (or from the + * offset position, if specified) in + * source to dest. If + * maxlength is not specified, all remaining content in + * source will be copied. + * + * @param resource $source The source stream + * @param resource $dest The destination stream + * @param int $maxlength Maximum bytes to copy + * @param int $offset The offset where to start to copy data + * @return int Returns the total count of bytes copied. + * @throws StreamException + * + */ +function stream_copy_to_stream($source, $dest, int $maxlength = -1, int $offset = 0): int +{ + error_clear_last(); + $result = \stream_copy_to_stream($source, $dest, $maxlength, $offset); + if ($result === false) { + throw StreamException::createFromPhpError(); + } + return $result; +} + + +/** + * Adds filtername to the list of filters + * attached to stream. + * + * @param resource $stream The target stream. + * @param string $filtername The filter name. + * @param int $read_write By default, stream_filter_append will + * attach the filter to the read filter chain + * if the file was opened for reading (i.e. File Mode: + * r, and/or +). The filter + * will also be attached to the write filter chain + * if the file was opened for writing (i.e. File Mode: + * w, a, and/or +). + * STREAM_FILTER_READ, + * STREAM_FILTER_WRITE, and/or + * STREAM_FILTER_ALL can also be passed to the + * read_write parameter to override this behavior. + * @param mixed $params This filter will be added with the specified + * params to the end of + * the list and will therefore be called last during stream operations. + * To add a filter to the beginning of the list, use + * stream_filter_prepend. + * @return resource Returns a resource on success. The resource can be + * used to refer to this filter instance during a call to + * stream_filter_remove. + * + * FALSE is returned if stream is not a resource or + * if filtername cannot be located. + * @throws StreamException + * + */ +function stream_filter_append($stream, string $filtername, int $read_write = null, $params = null) +{ + error_clear_last(); + if ($params !== null) { + $result = \stream_filter_append($stream, $filtername, $read_write, $params); + } elseif ($read_write !== null) { + $result = \stream_filter_append($stream, $filtername, $read_write); + } else { + $result = \stream_filter_append($stream, $filtername); + } + if ($result === false) { + throw StreamException::createFromPhpError(); + } + return $result; +} + + +/** + * Adds filtername to the list of filters + * attached to stream. + * + * @param resource $stream The target stream. + * @param string $filtername The filter name. + * @param int $read_write By default, stream_filter_prepend will + * attach the filter to the read filter chain + * if the file was opened for reading (i.e. File Mode: + * r, and/or +). The filter + * will also be attached to the write filter chain + * if the file was opened for writing (i.e. File Mode: + * w, a, and/or +). + * STREAM_FILTER_READ, + * STREAM_FILTER_WRITE, and/or + * STREAM_FILTER_ALL can also be passed to the + * read_write parameter to override this behavior. + * See stream_filter_append for an example of + * using this parameter. + * @param mixed $params This filter will be added with the specified params + * to the beginning of the list and will therefore be + * called first during stream operations. To add a filter to the end of the + * list, use stream_filter_append. + * @return resource Returns a resource on success. The resource can be + * used to refer to this filter instance during a call to + * stream_filter_remove. + * + * FALSE is returned if stream is not a resource or + * if filtername cannot be located. + * @throws StreamException + * + */ +function stream_filter_prepend($stream, string $filtername, int $read_write = null, $params = null) +{ + error_clear_last(); + if ($params !== null) { + $result = \stream_filter_prepend($stream, $filtername, $read_write, $params); + } elseif ($read_write !== null) { + $result = \stream_filter_prepend($stream, $filtername, $read_write); + } else { + $result = \stream_filter_prepend($stream, $filtername); + } + if ($result === false) { + throw StreamException::createFromPhpError(); + } + return $result; +} + + +/** + * stream_filter_register allows you to implement + * your own filter on any registered stream used with all the other + * filesystem functions (such as fopen, + * fread etc.). + * + * @param string $filtername The filter name to be registered. + * @param string $classname To implement a filter, you need to define a class as an extension of + * php_user_filter with a number of member + * functions. When performing read/write operations on the stream + * to which your filter is attached, PHP will pass the data through your + * filter (and any other filters attached to that stream) so that the + * data may be modified as desired. You must implement the methods + * exactly as described in php_user_filter - doing + * otherwise will lead to undefined behaviour. + * @throws StreamException + * + */ +function stream_filter_register(string $filtername, string $classname): void +{ + error_clear_last(); + $result = \stream_filter_register($filtername, $classname); + if ($result === false) { + throw StreamException::createFromPhpError(); + } +} + + +/** + * Removes a stream filter previously added to a stream with + * stream_filter_prepend or + * stream_filter_append. Any data remaining in the + * filter's internal buffer will be flushed through to the next filter before + * removing it. + * + * @param resource $stream_filter The stream filter to be removed. + * @throws StreamException + * + */ +function stream_filter_remove($stream_filter): void +{ + error_clear_last(); + $result = \stream_filter_remove($stream_filter); + if ($result === false) { + throw StreamException::createFromPhpError(); + } +} + + +/** + * Identical to file_get_contents, except that + * stream_get_contents operates on an already open + * stream resource and returns the remaining contents in a string, up to + * maxlength bytes and starting at the specified + * offset. + * + * @param resource $handle A stream resource (e.g. returned from fopen) + * @param int $maxlength The maximum bytes to read. Defaults to -1 (read all the remaining + * buffer). + * @param int $offset Seek to the specified offset before reading. If this number is negative, + * no seeking will occur and reading will start from the current position. + * @return string Returns a string. + * @throws StreamException + * + */ +function stream_get_contents($handle, int $maxlength = -1, int $offset = -1): string +{ + error_clear_last(); + $result = \stream_get_contents($handle, $maxlength, $offset); + if ($result === false) { + throw StreamException::createFromPhpError(); + } + return $result; +} + + +/** + * Determines if stream stream refers to a valid terminal type device. + * This is a more portable version of posix_isatty, since it works on Windows systems too. + * + * @param resource $stream + * @throws StreamException + * + */ +function stream_isatty($stream): void +{ + error_clear_last(); + $result = \stream_isatty($stream); + if ($result === false) { + throw StreamException::createFromPhpError(); + } +} + + +/** + * Resolve filename against the include path according to the same rules as fopen/include. + * + * @param string $filename The filename to resolve. + * @return string Returns a string containing the resolved absolute filename. + * @throws StreamException + * + */ +function stream_resolve_include_path(string $filename): string +{ + error_clear_last(); + $result = \stream_resolve_include_path($filename); + if ($result === false) { + throw StreamException::createFromPhpError(); + } + return $result; +} + + +/** + * Sets blocking or non-blocking mode on a stream. + * + * This function works for any stream that supports non-blocking mode + * (currently, regular files and socket streams). + * + * @param resource $stream The stream. + * @param bool $mode If mode is FALSE, the given stream + * will be switched to non-blocking mode, and if TRUE, it + * will be switched to blocking mode. This affects calls like + * fgets and fread + * that read from the stream. In non-blocking mode an + * fgets call will always return right away + * while in blocking mode it will wait for data to become available + * on the stream. + * @throws StreamException + * + */ +function stream_set_blocking($stream, bool $mode): void +{ + error_clear_last(); + $result = \stream_set_blocking($stream, $mode); + if ($result === false) { + throw StreamException::createFromPhpError(); + } +} + + +/** + * Sets the timeout value on stream, + * expressed in the sum of seconds and + * microseconds. + * + * When the stream times out, the 'timed_out' key of the array returned by + * stream_get_meta_data is set to TRUE, although no + * error/warning is generated. + * + * @param resource $stream The target stream. + * @param int $seconds The seconds part of the timeout to be set. + * @param int $microseconds The microseconds part of the timeout to be set. + * @throws StreamException + * + */ +function stream_set_timeout($stream, int $seconds, int $microseconds = 0): void +{ + error_clear_last(); + $result = \stream_set_timeout($stream, $seconds, $microseconds); + if ($result === false) { + throw StreamException::createFromPhpError(); + } +} + + +/** + * Accept a connection on a socket previously created by + * stream_socket_server. + * + * @param resource $server_socket The server socket to accept a connection from. + * @param float $timeout Override the default socket accept timeout. Time should be given in + * seconds. + * @param string|null $peername Will be set to the name (address) of the client which connected, if + * included and available from the selected transport. + * + * Can also be determined later using + * stream_socket_get_name. + * @return resource Returns a stream to the accepted socket connection. + * @throws StreamException + * + */ +function stream_socket_accept($server_socket, float $timeout = null, ?string &$peername = null) +{ + error_clear_last(); + if ($peername !== null) { + $result = \stream_socket_accept($server_socket, $timeout, $peername); + } elseif ($timeout !== null) { + $result = \stream_socket_accept($server_socket, $timeout); + } else { + $result = \stream_socket_accept($server_socket); + } + if ($result === false) { + throw StreamException::createFromPhpError(); + } + return $result; +} + + +/** + * Initiates a stream or datagram connection to the destination specified + * by remote_socket. The type of socket created + * is determined by the transport specified using standard URL formatting: + * transport://target. For Internet Domain sockets + * (AF_INET) such as TCP and UDP, the target portion + * of the remote_socket parameter should consist of + * a hostname or IP address followed by a colon and a port number. For Unix + * domain sockets, the target portion should point + * to the socket file on the filesystem. + * + * @param string $remote_socket Address to the socket to connect to. + * @param int $errno Will be set to the system level error number if connection fails. + * @param string $errstr Will be set to the system level error message if the connection fails. + * @param float $timeout Number of seconds until the connect() system call + * should timeout. + * + * + * This parameter only applies when not making asynchronous + * connection attempts. + * + * + * + * + * To set a timeout for reading/writing data over the socket, use the + * stream_set_timeout, as the + * timeout only applies while making connecting + * the socket. + * + * + * + * To set a timeout for reading/writing data over the socket, use the + * stream_set_timeout, as the + * timeout only applies while making connecting + * the socket. + * @param int $flags Bitmask field which may be set to any combination of connection flags. + * Currently the select of connection flags is limited to + * STREAM_CLIENT_CONNECT (default), + * STREAM_CLIENT_ASYNC_CONNECT and + * STREAM_CLIENT_PERSISTENT. + * @param resource $context A valid context resource created with stream_context_create. + * @return resource On success a stream resource is returned which may + * be used together with the other file functions (such as + * fgets, fgetss, + * fwrite, fclose, and + * feof), FALSE on failure. + * @throws StreamException + * + */ +function stream_socket_client(string $remote_socket, int &$errno = null, string &$errstr = null, float $timeout = null, int $flags = STREAM_CLIENT_CONNECT, $context = null) +{ + error_clear_last(); + if ($context !== null) { + $result = \stream_socket_client($remote_socket, $errno, $errstr, $timeout, $flags, $context); + } elseif ($flags !== STREAM_CLIENT_CONNECT) { + $result = \stream_socket_client($remote_socket, $errno, $errstr, $timeout, $flags); + } elseif ($timeout !== null) { + $result = \stream_socket_client($remote_socket, $errno, $errstr, $timeout); + } else { + $result = \stream_socket_client($remote_socket, $errno, $errstr); + } + if ($result === false) { + throw StreamException::createFromPhpError(); + } + return $result; +} + + +/** + * stream_socket_pair creates a pair of connected, + * indistinguishable socket streams. This function is commonly used in IPC + * (Inter-Process Communication). + * + * @param int $domain The protocol family to be used: STREAM_PF_INET, + * STREAM_PF_INET6 or + * STREAM_PF_UNIX + * @param int $type The type of communication to be used: + * STREAM_SOCK_DGRAM, + * STREAM_SOCK_RAW, + * STREAM_SOCK_RDM, + * STREAM_SOCK_SEQPACKET or + * STREAM_SOCK_STREAM + * @param int $protocol The protocol to be used: STREAM_IPPROTO_ICMP, + * STREAM_IPPROTO_IP, + * STREAM_IPPROTO_RAW, + * STREAM_IPPROTO_TCP or + * STREAM_IPPROTO_UDP + * @return resource[] Returns an array with the two socket resources on success. + * @throws StreamException + * + */ +function stream_socket_pair(int $domain, int $type, int $protocol): iterable +{ + error_clear_last(); + $result = \stream_socket_pair($domain, $type, $protocol); + if ($result === false) { + throw StreamException::createFromPhpError(); + } + return $result; +} + + +/** + * Creates a stream or datagram socket on the specified + * local_socket. + * + * This function only creates a socket, to begin accepting connections + * use stream_socket_accept. + * + * @param string $local_socket The type of socket created is determined by the transport specified + * using standard URL formatting: transport://target. + * + * For Internet Domain sockets (AF_INET) such as TCP and UDP, the + * target portion of the + * remote_socket parameter should consist of a + * hostname or IP address followed by a colon and a port number. For + * Unix domain sockets, the target portion should + * point to the socket file on the filesystem. + * + * Depending on the environment, Unix domain sockets may not be available. + * A list of available transports can be retrieved using + * stream_get_transports. See + * for a list of bulitin transports. + * @param int $errno If the optional errno and errstr + * arguments are present they will be set to indicate the actual system + * level error that occurred in the system-level socket(), + * bind(), and listen() calls. If + * the value returned in errno is + * 0 and the function returned FALSE, it is an + * indication that the error occurred before the bind() + * call. This is most likely due to a problem initializing the socket. + * Note that the errno and + * errstr arguments will always be passed by reference. + * @param string $errstr See errno description. + * @param int $flags A bitmask field which may be set to any combination of socket creation + * flags. + * + * For UDP sockets, you must use STREAM_SERVER_BIND as + * the flags parameter. + * @param resource $context + * @return resource Returns the created stream. + * @throws StreamException + * + */ +function stream_socket_server(string $local_socket, int &$errno = null, string &$errstr = null, int $flags = STREAM_SERVER_BIND | STREAM_SERVER_LISTEN, $context = null) +{ + error_clear_last(); + if ($context !== null) { + $result = \stream_socket_server($local_socket, $errno, $errstr, $flags, $context); + } else { + $result = \stream_socket_server($local_socket, $errno, $errstr, $flags); + } + if ($result === false) { + throw StreamException::createFromPhpError(); + } + return $result; +} + + +/** + * Shutdowns (partially or not) a full-duplex connection. + * + * @param resource $stream An open stream (opened with stream_socket_client, + * for example) + * @param int $how One of the following constants: STREAM_SHUT_RD + * (disable further receptions), STREAM_SHUT_WR + * (disable further transmissions) or + * STREAM_SHUT_RDWR (disable further receptions and + * transmissions). + * @throws StreamException + * + */ +function stream_socket_shutdown($stream, int $how): void +{ + error_clear_last(); + $result = \stream_socket_shutdown($stream, $how); + if ($result === false) { + throw StreamException::createFromPhpError(); + } +} + + +/** + * Tells whether the stream supports locking through + * flock. + * + * @param resource $stream The stream to check. + * @throws StreamException + * + */ +function stream_supports_lock($stream): void +{ + error_clear_last(); + $result = \stream_supports_lock($stream); + if ($result === false) { + throw StreamException::createFromPhpError(); + } +} + + +/** + * Allows you to implement your own protocol handlers and streams for use + * with all the other filesystem functions (such as fopen, + * fread etc.). + * + * @param string $protocol The wrapper name to be registered. + * @param string $classname The classname which implements the protocol. + * @param int $flags Should be set to STREAM_IS_URL if + * protocol is a URL protocol. Default is 0, local + * stream. + * @throws StreamException + * + */ +function stream_wrapper_register(string $protocol, string $classname, int $flags = 0): void +{ + error_clear_last(); + $result = \stream_wrapper_register($protocol, $classname, $flags); + if ($result === false) { + throw StreamException::createFromPhpError(); + } +} + + +/** + * Restores a built-in wrapper previously unregistered with + * stream_wrapper_unregister. + * + * @param string $protocol + * @throws StreamException + * + */ +function stream_wrapper_restore(string $protocol): void +{ + error_clear_last(); + $result = \stream_wrapper_restore($protocol); + if ($result === false) { + throw StreamException::createFromPhpError(); + } +} + + +/** + * Allows you to disable an already defined stream wrapper. Once the wrapper + * has been disabled you may override it with a user-defined wrapper using + * stream_wrapper_register or reenable it later on with + * stream_wrapper_restore. + * + * @param string $protocol + * @throws StreamException + * + */ +function stream_wrapper_unregister(string $protocol): void +{ + error_clear_last(); + $result = \stream_wrapper_unregister($protocol); + if ($result === false) { + throw StreamException::createFromPhpError(); + } +} |